diff -r 12af337248b1 -r bd7edf625bdd notepad/notepad1/LibSrc/NpdEditorDialog.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/notepad/notepad1/LibSrc/NpdEditorDialog.cpp Wed Sep 01 12:32:31 2010 +0100 @@ -0,0 +1,1253 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "NpdLib.hrh" +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#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() || iSequence->Count() == 1 ) + { + 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; + } + + switch (aCommandId) + { + case EAknSoftkeyExit: + case EAknCmdExit: + TryExitL(EAknSoftkeyExit); + iAvkonAppUi->ProcessCommandL(EAknCmdExit); + break; + case ENotepadCmdAdd: + OnCmdAddL(); + break; + case ENotepadCmdNextMemo: + iRedrawBackground = ETrue; + OnCmdNextMemoL(); + break; + case ENotepadCmdPreviousMemo: + iRedrawBackground = ETrue; + OnCmdPreviousMemoL(); + break; + case ENotepadCmdDelete: + OnCmdDeleteL(); + break; + case ENotepadCmdSend: + SendAsL( *iSendUi, aCommandId, EFalse, NULL, iEditor->Text() ); + if ( IsExitDelayedBySendUi() ) + { + delete iListDialog; + iListDialog = NULL; + } + default: + { + const TInt aiwServiceCmd( iServiceHandler ? iServiceHandler->ServiceCmdByMenuCmd( aCommandId ) : 0 ); + if ( aiwServiceCmd == KAiwCmdPrint ) + { + CAiwGenericParamList& inParams = iServiceHandler->InParamListL(); + + // Just in case, save note to avoid situation when newly created + // note cannot be be printed + if ( iEditor->Text()->HasChanged() ) + { + if ( SaveOnExitL( ETrue ) != CNotepadModel::ENotepadModelRowNop ) + { + // Wait asynronously that memo is stored + if ( !iStoreWait.IsStarted() ) + { + iStoreWait.Start(); + } + } + } + + // Note index + TAiwGenericParam noteParam( EGenericParamNoteItem ); + const TInt32 noteKey = iKey; + noteParam.Value().Set( noteKey ); + inParams.AppendL( noteParam ); + + // Application uid + const TUid uid( KUidNotepad ); // Notepad Uid3 + TAiwGenericParam uidParam( EGenericParamApplication ); + uidParam.Value().Set( uid ); + inParams.AppendL( uidParam ); + + // Execute service command with given parameters + iServiceHandler->ExecuteMenuCmdL( aCommandId, + inParams, + iServiceHandler->OutParamListL(), + 0, + iListDialog + ); + break; + } + + CNotepadDialogBase::ProcessCommandL(aCommandId); + } + break; + } + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::HandleControlStateChangeL +// from CEikDialog +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::HandleControlStateChangeL(TInt aControlId ) + { + CNotepadDialogBase::HandleControlStateChangeL(aControlId); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::PreLayoutDynInitL +// from CEikDialog. +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::PreLayoutDynInitL() + { + iEditor = STATIC_CAST(CNotepadEdwin*, Control(ENotepadIdEdwin)); + TRect rect(iEikonEnv->EikAppUi()->ClientRect()); + iEditor->SetRect(rect); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OkToExitL +// ----------------------------------------------------------------------------- +// +TBool CNotepadEditorDialog::OkToExitL( TInt aButtonId ) + { + const TChar linefeed(0x21B2); + __ASSERT_DEBUG( iEditor, Panic(ENotepadLibraryPanicNoEdwin) ); + if (IsContainLinefeedSymbol(iEditor->Text()->Read(0, + iEditor->Text()->DocumentLength())) && !IsEmpty()) + { + return EFalse; + } + iFlags &= ~ENotepadMenuByOkKey; + TBool isOk(ETrue); + iTaskSwapperFlag= EFalse; + switch ( aButtonId ) + { + //MSK + case EAknSoftkeyContextOptions: + { + + iFlags |= ENotepadMenuByOkKey; + DisplayMenuL(); + isOk= EFalse; + } + break; + case EAknSoftkeyDone: + SaveOnExitL(ETrue); + break; + case EEikBidCancel: // Simulated by CAknShutter + case EAknSoftkeyExit: + { + TRAPD( err, SaveOnExitL( EFalse ); ); + if ( err ) + { + CEikonEnv::Static()->HandleError(err); + } + } + break; + + case EAknSoftkeyOptions: + iTaskSwapperFlag= ETrue; + if ( iFlags & ENotepadFindItemRuning ) + { + return EFalse; + } + default: + isOk = CAknDialog::OkToExitL( aButtonId ); + break; + } + return isOk; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::ActivateL +// from CoeControl. +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::ActivateL() + { + __ASSERT_DEBUG( iEditor, Panic(ENotepadLibraryPanicNoEdwin) ); + iEditor->ConstructBaseL(); + iEditor->InitNotepadEditorL(this, STATIC_CAST(CNotepadEdwinLines*, Control(ENotepadIdEdwinLines))); + iEditor->SetFocus(ETrue, ENoDrawNow); + CNotepadDialogBase::ActivateL(); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OfferKeyEventL +// from CCoeControl +// ----------------------------------------------------------------------------- +// +TKeyResponse CNotepadEditorDialog::OfferKeyEventL( + const TKeyEvent& aKeyEvent, + TEventCode aType ) + { + + + if ( iIdle ) + { + NumberKeyCallBack(this); + } + TKeyResponse keyResponse(EKeyWasConsumed); + + + if ( !MenuShowing() && aType == EEventKey && + !( aKeyEvent.iModifiers & (EAllStdModifiers|EModifierSpecial) ) && + ( aKeyEvent.iCode == EKeyOK ) ) + { + iFlags |= ENotepadMenuByOkKey; + DisplayMenuL(); + } + else + { + if ( aKeyEvent.iCode == EKeyNo || aKeyEvent.iCode == EKeyEscape ) + { + iExitByTerminateKey = ETrue; + } + keyResponse = CAknDialog::OfferKeyEventL(aKeyEvent, aType); + } + return keyResponse; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::GetHelpContext +// from CCoeControl +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::GetHelpContext(TCoeHelpContext& aContext) const + { + aContext.iMajor = KUidNotepad; + switch ( iResId ) + { + case R_NOTEPAD_EDITOR_DIALOG_ORG: + aContext.iContext = KNMAKE_HLP_MEMO_EDITOR; + break; + case R_NOTEPAD_TEMPLATE_EDITOR_DIALOG_ORG: + aContext.iContext = KNMAKE_HLP_TEMPLATE_EDITOR; + break; + default: + break; + } + } + +// --------------------------------------------------------- +// CNotepadEditorDialog::HandleResourceChange +// from CCoeControl +// --------------------------------------------------------- +// +void CNotepadEditorDialog::HandleResourceChange(TInt aType) + { + if ( aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch ) + { + CAknDialog::HandleResourceChange( aType ); + CEikDialog::Layout(); + if ( iEditor && IsActivated() ) + { + iEditor->HandleResourceChange(aType); + } + iEditor->DrawDeferred(); + } + else + { + CAknDialog::HandleResourceChange(aType); + } + if(iEditor) + { + iEditor->SetCursorVisible(IsFocused()); + } + } + +// --------------------------------------------------------- +// CNotepadEditorDialog::SizeChanged +// from CCoeControl +// --------------------------------------------------------- +// +void CNotepadEditorDialog::SizeChanged() + { + CNotepadDialogBase::SizeChanged(); + if (iEditor && IsActivated()) + { + TRAP_IGNORE(iEditor->DoEditorLayoutL()); + } + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::CNotepadEditorDialog +// private c++ constructor +// ----------------------------------------------------------------------------- +// +CNotepadEditorDialog::CNotepadEditorDialog( + CNotepadModel& aModel, + CNotepadListDialog* aListDialog ) + :CNotepadDialogBase(), iModel(aModel), iListDialog(aListDialog), + iKey(KNotepadPseudoKeyIdForNewNote), + iServiceHandler( NULL ) + { + } + + + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::SaveL +// +// Table: What shoud we do after saving? +// mode before saving, rowResult -> entry in iSequence +// 1. adding nop -> nop +// 2. adding added -> insert to top +// 3. editing nop -> nop +// 4. editing updated -> update the entry +// 5. editing added -> update the entry +// 6. editing deleted -> remove the entry +// +// In case 6, the info note "Memo delted" should be shown. +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::SaveL() + { + __ASSERT_DEBUG(iEditor, Panic(ENotepadLibraryPanicNoEdwin)); + __ASSERT_DEBUG(iEditor->Text(), Panic(ENotepadLibraryPanicNoTextInEdwin)); + // in order to avoid leaving at *never leave* bellow + iSequence->SetReserveL(iSequence->Count()+1); // *reserve space* + const TBool wasModeAdding( IsModeAdding() ); + const TInt savedCurrentSequence( CurrentSequence() ); + TInt rowResult(CNotepadModel::ENotepadModelRowNop); + if ( iEditor->Text()->HasChanged() ) + { + if ( wasModeAdding ) + { + rowResult = iModel.InsertL( iEditor->Text()->Read( + 0, iEditor->Text()->DocumentLength()), iKey ); + // iKey is updated by InsertL if really added + } + else + { + rowResult = iModel.UpdateL( iEditor->Text()->Read( + 0, iEditor->Text()->DocumentLength()), iKey ); + // iKey is updated by InsertL if iKey doesn't exist or set as + // KNotepadPseudoKeyIdForNewNote if the entry was deleted + } + iEditor->Text()->SetHasChanged(EFalse); + } + if ( rowResult == CNotepadModel::ENotepadModelRowDeleted ) + { + if ( savedCurrentSequence != KNotepadInvalidSequenceIndex ) + { + iSequence->Delete(savedCurrentSequence); + } + + if ( !iExitByTerminateKey ) + { + TInt resid = IsNotepad() ? R_NOTEPAD_TEXT_DELETED_EMPTY_MEMO : R_NOTEPAD_TEXT_DELETED_EMPTY_TEMPLATE; + HBufC *text= StringLoader::LoadLC(resid); // text; + CAknInformationNote* note + = new(ELeave) CAknInformationNote(ETrue); + note->SetMopParent(this); + + note->ExecuteLD(*text); + CleanupStack::PopAndDestroy(text); + } + } + else + { + if ( wasModeAdding && + rowResult == CNotepadModel::ENotepadModelRowAdded ) + { + if ( IsNotepad() ) + { + iSequence->InsertL(1, iKey); // *never leave* because reserved + } + else + { + iSequence->InsertL(0, iKey); // *never leave* because reserved + } + + } + else if ( savedCurrentSequence != KNotepadInvalidSequenceIndex && + ( rowResult == CNotepadModel::ENotepadModelRowAdded || + rowResult == CNotepadModel::ENotepadModelRowUpdated ) ) + { + (*iSequence)[savedCurrentSequence] = iKey; + } + } + return rowResult; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OnCmdAddL +// This command will never be called +// in template Editor. +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::OnCmdAddL() + { + SaveL(); + SwitchTextL(KNotepadPseudoKeyIdForNewNote); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OnCmdNextMemoL +// +// Ever reported; +// 1. Notepad has memo "aaa", "bbb", "ddd" and open "aaa" in editor. +// 2. Edit "aaa" to be "". +// 3. Select 'Next memo' in Options menu. +// then, editor contents will be changed to "bbb" correctly, but +// Options menu has 'Previous memo' and nothing occurs if we select it. +// +// Table: What is next? +// mode before saving, rowResult -> nextIndex +// 1. adding nop -> 0 +// 2. adding added -> 1 +// 3. editing nop -> oldIndex+1 +// 4. editing updated -> oldIndex+1 +// 5. editing added -> oldIndex+1 +// 6. editing deleted -> oldIndex +// Of course, we must check the nextIndex so as not to exceed the total count. +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::OnCmdNextMemoL() + { + TInt nextIndex(1); + const TBool wasModeAdding( IsModeAdding() ); + if ( !wasModeAdding ) + { + nextIndex = CurrentSequence(); // oldIndex + } + const TInt stat(SaveL()); // iKey has not changed when deleted + if ( iSequence->Count() > 0 && + wasModeAdding ? + stat == CNotepadModel::ENotepadModelRowAdded : + stat != CNotepadModel::ENotepadModelRowDeleted ) + { + nextIndex++; + if ( nextIndex >= iSequence->Count() ) + { + nextIndex = iSequence->Count() - 1; + } + } + if ( iSequence->Count() > 0 ) + { + TInt nextKey( (*iSequence)[nextIndex] ); + if (nextKey != iKey) + { + SwitchTextL(nextKey); + } + } + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OnCmdPreviousMemoL +// +// Table: What is previous? +// mode before saving, rowResult -> previousIndex +// 1. editing nop -> oldIndex-1 +// 2. editing updated -> oldIndex-1 +// 3. editing added -> oldIndex-1 +// 4. editing deleted -> oldIndex-1 +// In adding mode, "Previous memo" is not available. +// Of course, we must check the previousIndex so as not to be less than 0. +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::OnCmdPreviousMemoL() + { + __ASSERT_DEBUG( IsModeEditing(), + Panic(ENotepadLibraryPanicEditorInvalidMode) ); + TInt previousIndex( CurrentSequence() ); // oldIndex + SaveL(); + if ( previousIndex > 0 ) + { + --previousIndex; + } + if ( iSequence->Count() > 0 ) + { + TInt previousKey( (*iSequence)[previousIndex] ); + if (previousKey != iKey) + { + SwitchTextL(previousKey); + } + } + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::OnCmdDeleteL +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::OnCmdDeleteL() + { + TInt deleteKey( IsModeEditing() ? iKey : KNotepadPseudoKeyIdForNewNote ); + if ( ExecuteConfirmationQueryL(QueryDeleteSingleResId()) ) + { + TInt returnKey( iKey ); + TInt stat(CNotepadModel::ENotepadModelRowNop); + iFlags &= ~ENotepadCatchSaveOnExitCallback; + if ( deleteKey >= 0 ) + { + const TBool isEditingFirst( + IsModeEditing() && IsSequenceAtFirst() ); + stat = iModel.DeleteL(deleteKey); + if ( !isEditingFirst && + stat == CNotepadModel::ENotepadModelRowDeleted ) + { + returnKey = NextKeyInSequence(); + } + } + iEditor->Text()->SetHasChanged(EFalse); // prevent saving + + iListDialog->HandleEditorExitL(stat, returnKey, + stat == CNotepadModel::ENotepadModelRowNop || + iFlags & ENotepadCatchSaveOnExitCallback ); + delete(this); // this is OK + } + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::NumberKeyCallBack +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::NumberKeyCallBack(TAny *aSelf) + { + CNotepadEditorDialog *self = STATIC_CAST(CNotepadEditorDialog*, aSelf); + delete self->iIdle; + self->iIdle = NULL; + // delete must preceed KeyEvent to avoid infinite loop of OfferKeyEventL + // + TRAPD(err, + self->iCoeEnv->SimulateKeyEventL(self->iEvent, EEventKeyDown); + self->iCoeEnv->SimulateKeyEventL(self->iEvent, EEventKey); + ); + if ( err != KErrNone ) + { + self->iEditor->CancelFepTransaction(); // indispensable to avoid crash + self->iCoeEnv->HandleError(err); + } + return FALSE; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::CreateSequenceL +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::CreateSequenceL() + { + delete iSequence; + iSequence = NULL; + iSequence = new(ELeave) CArrayFixFlat(KNotepadSequenceGranularity); + const RArray& keyArray = iModel.KeyArray(); + const TInt count(keyArray.Count()); + iFlags |= ENotepadRequireSequenceUpdate; // flag on + for (TInt i(0); i < count; i++) + { + iSequence->AppendL( keyArray[i] ); + } + iFlags &= ~ENotepadRequireSequenceUpdate; // flag off + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::SyncSequenceL +// ----------------------------------------------------------------------------- +// +void CNotepadEditorDialog::SyncSequenceL( const TBool aForceSync ) + { + if ( !iSequence || + !( aForceSync || iFlags & ENotepadRequireSequenceUpdate) ) + { + iFlags &= ~ENotepadRequireSequenceUpdate; // flag off + return; + } + iFlags |= ENotepadRequireSequenceUpdate; // flag on + const RArray& keyArray = iModel.KeyArray(); + + // Delete entries which no longer exist + // + TInt i(0); + for ( i = iSequence->Count() - 1; i >= 0; --i ) + { + if ( keyArray.Find((*iSequence)[i]) < 0 ) // not found + { + iSequence->Delete(i); + } + } + + // Add entries which is newly added after previous Create/SyncSequenceL + // + TInt index( 0 ); + TKeyArrayFix cmpKeyArray(0, ECmpTInt); + for (i = keyArray.Count() - 1; i >= 1; --i) + { + if (iSequence->Find(keyArray[i], cmpKeyArray, index) != 0) + { + iSequence->InsertL(1, keyArray[i]); + } + } + if (iKey != KNotepadPseudoKeyIdForNewNote + && iSequence->Find(iKey, cmpKeyArray, index) != 0) // not found + { + iKey = KNotepadPseudoKeyIdForNewNote; + } + iFlags &= ~ENotepadRequireSequenceUpdate; // flag off + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::IsSequenceAtLast +// ----------------------------------------------------------------------------- +// +TBool CNotepadEditorDialog::IsSequenceAtLast() const + { + __ASSERT_DEBUG( iSequence, + Panic(ENotepadLibraryPanicNullSequenceInEditor) ); + return ( IsModeAdding() ? iSequence->Count() == 1 : + CurrentSequence() == iSequence->Count() - 1 ); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::IsSequenceAtFirst +// ----------------------------------------------------------------------------- +// +TBool CNotepadEditorDialog::IsSequenceAtFirst() const + { + __ASSERT_DEBUG( iSequence, + Panic(ENotepadLibraryPanicNullSequenceInEditor) ); + return ( IsModeAdding() || CurrentSequence() == 1); + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::CurrentSequence +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::CurrentSequence() const + { + __ASSERT_DEBUG( iSequence, + Panic(ENotepadLibraryPanicNullSequenceInEditor) ); + TInt index(KNotepadInvalidSequenceIndex); + TKeyArrayFix cmpKeyArray(0, ECmpTInt); + iSequence->Find(iKey, cmpKeyArray, index); + return index; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::NextKeyInSequence +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::NextKeyInSequence() const + { + __ASSERT_DEBUG( iSequence, + Panic(ENotepadLibraryPanicNullSequenceInEditor) ); + TInt nextKey(iKey); + if ( iKey == KNotepadPseudoKeyIdForNewNote ) // IsModeAdding + { + if ( iSequence->Count() > 1 ) + { + nextKey = (*iSequence)[1]; + } + else if ( iSequence->Count() == 1 ) + { + nextKey = (*iSequence)[0]; + } + } + else + { + TInt index ( CurrentSequence() ); + if ( index < iSequence->Count() - 1 ) + { + nextKey = (*iSequence)[index+1]; + } + } + return nextKey; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::PreviousKeyInSequence +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::PreviousKeyInSequence() const + { + __ASSERT_DEBUG( iSequence, + Panic(ENotepadLibraryPanicNullSequenceInEditor) ); + __ASSERT_DEBUG( IsModeEditing(), + Panic(ENotepadLibraryPanicEditorInvalidMode) ); + TInt previousKey(iKey); + if ( IsModeEditing() ) + { + TInt index( CurrentSequence() ); + if ( index > 0 ) + { + previousKey = (*iSequence)[index - 1]; + } + } + return previousKey; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::DoSearchL +// ----------------------------------------------------------------------------- +// +TInt CNotepadEditorDialog::DoSearchL(CFindItemEngine::TFindItemSearchCase aCase) + { + CFindItemDialog* dialog = CFindItemDialog::NewL( iEditor->Text()->Read( 0 ), aCase ); + dialog->EnableSingleClick( ETrue ); + dialog->SetCallSubMenuVisibility( EFalse ); // Click-To-Call + TInt ret = dialog->ExecuteLD(); + return ret; + } + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::IsContainLinefeedSymbol +// ----------------------------------------------------------------------------- +// +TBool CNotepadEditorDialog::IsContainLinefeedSymbol(const TDesC& aDes) + { + const TChar linefeed(0x21B2); + for(TInt i = 0; i < aDes.Length(); i++) + { + TChar c(aDes[i]); + if(c == linefeed) + { + return ETrue; + } + } + return EFalse; + } + +// CNotepadEditorDialog::FocusChanged +// ----------------------------------------------------------------------------- +// +#ifdef RD_INTELLIGENT_TEXT_INPUT +void CNotepadEditorDialog::FocusChanged(TDrawNow /*aDrawNow*/) + { + if(iEditor) + { + iEditor->SetCursorVisible(IsFocused()); + } + } +#endif + +// ----------------------------------------------------------------------------- +// CNotepadEditorDialog::CNotepadEditorDialog_Reserved +// ----------------------------------------------------------------------------- +// +EXPORT_C void CNotepadEditorDialog::CNotepadEditorDialog_Reserved() + { + } + +// End of File