1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of List of Memos/Templates mode.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <bldvariant.hrh>

    22 #include <eikmenup.h>

    23 #include <eikclbd.h>

    24 #include <eikapp.h>

    25 #include <aknlists.h>

    26 #include <bacntf.h>

    27 #include <sendui.h>

    28 #include <Sendnorm.rsg>

    29 #include <txtglobl.h>

    30 #include <AknIconArray.h>

    31 #include <StringLoader.h>

    32 #include <AknDlgShut.h>

    33 #include <AknProgressDialog.h>

    34 #include <eikprogi.h>

    35 #include <eikimage.h>

    36 

    37 #include <AvkonIcons.hrh>

    38 #include <avkon.mbg>

    39 #include <aknlayoutscalable_avkon.cdl.h>

    40 #include <gulicon.h>

    41 #include <aknconsts.h>

    42 #include <hlplch.h>

    43 #include <featmgr.h>

    44 #include <StringLoader.h>

    45 #include <NpdLib.rsg>

    46 #include <AiwCommon.hrh>

    47 #include <AiwGenericParam.h>

    48 #include <CMessageData.h>

    49 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    50 #include <vwsdefpartner.h>

    51 #endif

    52 #include "NpdLib.hrh"

    53 #include "NpdListDialog.h"

    54 #include "NpdEditorDialog.h"

    55 #include "NpdModel_platsec.h"

    56 #include "NpdLib.h"

    57 #include "NpdListBox.h"

    58 

    59 #include <csxhelp/nmake.hlp.hrh>

    60 #include <csxhelp/mce.hlp.hrh>

    61 

    62 // Next is for KNotepadPseudoKeyIdForNewNote

    63 //

    64 #include "NpdApi.h"

    65 #include "NpdLibPanic.h"

    66 

    67 //number of fixed item

    68 //currently, Notepad application have one fixed "New Note" item in main view. 

    69 const TInt KNumberOfFixedItem = 1; 

    70 

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

    72 

    73 // -----------------------------------------------------------------------------

    74 // CNotepadListDialog::NewL

    75 // Constructor.

    76 // -----------------------------------------------------------------------------

    77 //

    78 EXPORT_C CNotepadListDialog* CNotepadListDialog::NewL(

    79     TInt aResId,             // Resource Id of type NOTEPAD_LIST_DIALOG

    80     CEikDialog** aSelfPtr )

    81     {

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

    83     self->iSelfPtr = aSelfPtr;

    84     CleanupStack::PushL(self);

    85     TResourceReader rr;

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

    87     self->ConstructL( rr );

    88     CleanupStack::PopAndDestroy(); // rr

    89     CleanupStack::Pop(); // self

    90     return self;

    91     }

    92 

    93 // -----------------------------------------------------------------------------

    94 // CNotepadListDialog::~CNotepadListDialog

    95 // Destructor.

    96 //

    97 // In destructor of CNotepadEditorDialog, 

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

    99 // NULLed using CNotepadListDialog::EditorDeleted().

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

   101 //

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

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

   104 // Because the focus is changed in deleting iProgressDialog 

   105 // (caused by RemoveFromStack).

   106 // -----------------------------------------------------------------------------

   107 //

   108 EXPORT_C CNotepadListDialog::~CNotepadListDialog()

   109     {

   110     delete iIdle;

   111     delete iProgressDialog; // *1*

   112     delete iEditorDialog;

   113     if ( iFlags & ENotepadObserveView )

   114         {

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

   116         }

   117     delete iModel;

   118     delete iSendUi;

   119     iSavedSelectedKeys.Close();

   120     iSavedKeysAboveCurrent.Close();

   121     delete iEnvironmentChangeNotifier;

   122     if ( iServiceHandler )

   123     	{

   124     	    	

   125 		delete iServiceHandler;

   126 		iServiceHandler = NULL;

   127     	}

   128     }

   129 

   130 // -----------------------------------------------------------------------------

   131 // CNotepadListDialog::EditByKeyL

   132 // Called from CNotepadAppUi.

   133 // -----------------------------------------------------------------------------

   134 //

   135 EXPORT_C void CNotepadListDialog::EditByKeyL(const TInt aKey)

   136     {

   137     __ASSERT_DEBUG( IsNotepad(), 

   138         Panic(ENotepadLibraryPanicOnlySupportedInNotepad) );

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

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

   141        	&& !iModel->IsDeleting() )

   142         {

   143         DoEditByKeyL(aKey);

   144         }

   145     }

   146 

   147 // -----------------------------------------------------------------------------

   148 // CNotepadListDialog::SaveL

   149 // -----------------------------------------------------------------------------

   150 //

   151 EXPORT_C void CNotepadListDialog::SaveL()

   152     {

   153     if ( iEditorDialog )

   154         {

   155         iEditorDialog->SaveOnExitL(EFalse);

   156         }

   157     }

   158 

   159 // -----------------------------------------------------------------------------

   160 // CNotepadListDialog::HandleEditorExitL

   161 // This function is called from CNotepadEditorDialog.

   162 // -----------------------------------------------------------------------------

   163 //

   164 void CNotepadListDialog::HandleEditorExitL(

   165     TInt aStatOfSave, 

   166     const TInt aKey,

   167     const TBool aEagerSync )

   168     {

   169     	iEditorFlag= EFalse;

   170     if ( aKey != KNotepadPseudoKeyIdForNewNote )

   171         {

   172         iSavedKey = aKey;

   173         }

   174     if ( aStatOfSave == CNotepadModel::ENotepadModelRowAdded )

   175         {

   176         iFlags |= ENotepadItemAdded;

   177         }

   178     else 

   179         {

   180         iFlags &= ~ENotepadItemAdded;

   181         }

   182     if ( aEagerSync && iClockValueChange )

   183         {

   184         iModel->SetItemArrayFlags();

   185         iClockValueChange = EFalse;        

   186         }

   187     if (aStatOfSave == CNotepadModel::ENotepadModelRowDeleted)

   188     	{

   189     	iListBox->HandleItemRemovalL();

   190     	DrawNow();

   191     	}

   192     iModel->SyncL(EFalse);

   193     RestoreCurrentAndSelectionsL();

   194     DrawNow();

   195         // MSK 

   196         MiddleSoftKeyL();

   197     }

   198 

   199 // -----------------------------------------------------------------------------

   200 // CNotepadListDialog::EditorDeleted

   201 // -----------------------------------------------------------------------------

   202 //

   203 void CNotepadListDialog::EditorDeleted()

   204     {

   205     iEditorDialog = NULL;

   206     iModel->SetNotepadModelObserver(this); 

   207     }

   208 

   209 // -----------------------------------------------------------------------------

   210 // CNotepadListDialog::ConstructL

   211 // private second-phase constructor

   212 // -----------------------------------------------------------------------------

   213 //

   214 void CNotepadListDialog::ConstructL( TResourceReader& aReader )

   215     {

   216     iNeedSave = EFalse;

   217     iSavedKey = KNotepadInvalidKeyId;

   218     iSendingEmail = EFalse;

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

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

   221     iModel = CNotepadModel::NewL(

   222         iCoeEnv->FsSession(), modelResId );

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

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

   225     if ( ptr.Length() )

   226         {

   227         SetTitleL(&ptr);

   228         }

   229 

   230     iSendUi = CSendUi::NewL();

   231     if ( IsNotepad() )

   232         {

   233         TCallBack callback(HandleEnvironmentChangedL, this);

   234         iEnvironmentChangeNotifier = CEnvironmentChangeNotifier::NewL(

   235             EActivePriorityLogonA, callback);

   236         iEnvironmentChangeNotifier->Start();

   237         }

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

   239     iFlags |= ENotepadObserveView;

   240     iClockValueChange = EFalse;

   241     iBaseAppUi = iAvkonAppUi;

   242     iModel->SetNotepadModelObserver(this);

   243     iBaseLevelOfActiveScheduler = LevelOfActiveScheduler() + 1;

   244     // Create instance of CAiwServiceHandler

   245 	iServiceHandler = CAiwServiceHandler::NewL();

   246 	// Attach menu services

   247 	iServiceHandler->AttachMenuL( R_NOTEPAD_LIST_MENU_SECOND, R_NOTEPAD_APP_INTEREST );

   248     if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

   249         {

   250         iServiceHandler->AttachMenuL( R_NOTEPAD_LIST_MENU_FIRST, R_PS_AIW_INTEREST );

   251         }

   252     }

   253 

   254 // -----------------------------------------------------------------------------

   255 // CNotepadListDialog::StartEditorL

   256 // -----------------------------------------------------------------------------

   257 //

   258 void CNotepadListDialog::StartEditorL()

   259     {

   260     iEditorFlag=ETrue;

   261     HideMenu();

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

   263     

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

   265             iSendUi);

   266 

   267     iEditorDialog->ExecuteLD();

   268     iListBox->ClearSelection();

   269     ClearSavedCurrentAndSelections();

   270     SaveCurrentAndSelectionsL();

   271     }

   272 

   273 // -----------------------------------------------------------------------------

   274 // CNotepadListDialog::OnCmdAddL

   275 // -----------------------------------------------------------------------------

   276 //

   277 	void CNotepadListDialog::OnCmdAddL()

   278     {

   279     StartEditorL();

   280     iEditorDialog->SwitchTextL(KNotepadPseudoKeyIdForNewNote);

   281     }

   282 

   283 // -----------------------------------------------------------------------------

   284 // CNotepadListDialog::OnCmdOpenL

   285 // -----------------------------------------------------------------------------

   286 //

   287 void CNotepadListDialog::OnCmdOpenL(TInt aIndex)

   288     {

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

   290         {

   291     	  return;

   292         }

   293     StartEditorL();

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

   295     }

   296 

   297 // -----------------------------------------------------------------------------

   298 // CNotepadListDialog::ConfirmDeleteL

   299 // -----------------------------------------------------------------------------

   300 //

   301 TBool CNotepadListDialog::ConfirmDeleteL(TInt aMemos)

   302     {

   303     TBool isConfirmed(ETrue);

   304     if ( aMemos >= 2 )

   305         {

   306         HBufC* prompt = StringLoader::LoadLC(

   307             QueryDeleteMultipleResId(), aMemos, iCoeEnv);

   308         isConfirmed = ExecuteConfirmationQueryL(prompt);

   309         CleanupStack::PopAndDestroy(); // prompt

   310         }

   311     else 

   312         {

   313         isConfirmed = ExecuteConfirmationQueryL(QueryDeleteSingleResId());

   314         }

   315     return isConfirmed;

   316     }

   317 

   318 // -----------------------------------------------------------------------------

   319 // CNotepadListDialog::CreateKeyArrayOfSelectionsL

   320 // -----------------------------------------------------------------------------

   321 //

   322 void CNotepadListDialog::CreateKeyArrayOfSelectionsL()

   323     {

   324     const CListBoxView::CSelectionIndexArray* selections = 

   325         iListBox->SelectionIndexes();

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

   327     iSavedSelectedKeys.Reset();

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

   329         {

   330         User::LeaveIfError(

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

   332         }

   333     }

   334 

   335 // -----------------------------------------------------------------------------

   336 // CNotepadListDialog::OnCmdDeleteL

   337 //

   338 //                  IsNotepad    IsTemplates

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

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

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

   342 //

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

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

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

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

   347 //

   348 // And there are 3 different labels defined;

   349 //   (1) "Deleting" 

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

   351 //   (3) "Deleting template"

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

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

   354 // -----------------------------------------------------------------------------

   355 //

   356 void CNotepadListDialog::OnCmdDeleteL()

   357     {

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

   359     //For clear key,if nothing can be deleted ,do not handle the clear key

   360     if ( iModel->MdcaCount() == 0 || ( markCount == 0 && !iListBox->IsHighlightEnabled() ) ) 

   361         {

   362         return;

   363         }

   364     

   365     //Fixed Item 'New Note' in notes should not be deleted

   366     if ( IsNoteListDialog() && ( iListBox->CurrentItemIndex() == 0 ) && markCount == 0 )

   367         {

   368         return;

   369         }

   370     

   371     ClearSavedCurrentAndSelections();

   372     SaveCurrentAndSelectionsL();

   373     

   374     TInt deleteCount;

   375     if ( iListBox->IsHighlightEnabled() && markCount == 0 )

   376         {

   377         //for an Item highlighted and no Item marked

   378         deleteCount = 1;

   379         }

   380     else

   381         {

   382         deleteCount = markCount;

   383         }

   384     

   385     if ( ConfirmDeleteL( deleteCount ) )

   386         {

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

   388         //

   389         if ( markCount > 0 ? 

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

   391             iModel->MdcaCount() > 0 )

   392             {

   393             // assert "deleteCount >= 1"

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

   395                 { //**A**

   396                 // Both Notepad and MCE specs require ProgressDialog

   397                 // in deleting multiple items.

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

   399                 //

   400                 CreateProgressDialogL(deleteCount,

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

   402                     R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE :

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

   404                         R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATES :

   405                         0 )); // default label for Notepad

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

   407                 }

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

   409                 { //**B**

   410                 // MCE spec requires ProgressDialog even in deleting one item

   411                 //

   412                 RArray<TInt> keys(1);

   413                 CleanupClosePushL(keys);

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

   415                 CreateProgressDialogL( deleteCount, 

   416                     R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE );

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

   418                 CleanupStack::PopAndDestroy();// keys

   419                 }

   420             else 

   421                 { //**C**

   422                 // Notepad spec doesn't require ProgressDialog 

   423                 // in deleting a single item

   424                 //

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

   426                     iSavedSelectedKeys[0] );

   427                 }

   428             }

   429         }

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

   431     }

   432 

   433 // -----------------------------------------------------------------------------

   434 // CNotepadListDialog::OnCmdSendL

   435 // -----------------------------------------------------------------------------

   436 //

   437 void CNotepadListDialog::OnCmdSendL(TInt aCommandId)

   438     {

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

   440         {

   441     	  return;

   442         }    

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

   444         {

   445         ClearSavedCurrentAndSelections();

   446         SaveCurrentAndSelectionsL();

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

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

   449         TUid EmailUid = {0x10001028};

   450         if ( serviceUid == EmailUid )

   451         	{

   452         	iSendingEmail = ETrue;

   453         	}

   454         }

   455     else

   456         {

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

   458         CleanupStack::PushL(text);

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

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

   461         CleanupStack::PopAndDestroy(); // text

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

   463         }

   464     }

   465 

   466 // -----------------------------------------------------------------------------

   467 // CNotepadListDialog::CreateProgressDialogL

   468 // -----------------------------------------------------------------------------

   469 //

   470 void CNotepadListDialog::CreateProgressDialogL(

   471     const TInt aCount,

   472     const TInt aLabelResId )

   473     {

   474     __ASSERT_DEBUG( aCount >= 1, 

   475         Panic(ENotepadLibraryPanicInvalidFinalValueOfProgressNote) );

   476     delete iProgressDialog;

   477     iProgressDialog = NULL;

   478     iProgressDialog = new(ELeave) CNotepadProgressDialog(

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

   480       		

   481     iProgressDialog->SetMopParent(this);

   482         

   483     iProgressDialog->PrepareLC(R_NOTEPAD_DELETE_PROGRESS_NOTE);    

   484         

   485     iProgressDialog->PrepareL(aCount, aLabelResId);

   486     iProgressDialog->ProgressInfo()->SetFinalValue( 

   487         aLabelResId == 0 ? 

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

   489             : aCount );

   490      iProgressDialog->SetCallback(this);   

   491     iProgressDialog->RunLD();

   492     }

   493 

   494 // -----------------------------------------------------------------------------

   495 // CNotepadListDialog::DoEditByKeyL

   496 // -----------------------------------------------------------------------------

   497 //

   498 void CNotepadListDialog::DoEditByKeyL(const TInt aKey)

   499     {

   500     iModel->SyncL(EFalse);

   501     if ( iEditorDialog )

   502         {

   503         iEditorDialog->EditByKeyL(aKey, *iBaseAppUi);

   504         }

   505 	else if ( aKey != KNotepadPseudoKeyIdForNewNote 

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

   507 		{

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

   509 		OnCmdOpenL( iModel->IndexOf(aKey) );

   510 		}

   511     else

   512         {

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

   514        	OnCmdAddL();

   515         }

   516     }

   517 

   518 // -----------------------------------------------------------------------------

   519 // CNotepadListDialog::HandleEnvironmentChangedL

   520 // private static function.

   521 // -----------------------------------------------------------------------------

   522 //

   523 TInt CNotepadListDialog::HandleEnvironmentChangedL( TAny* aThisPtr )

   524     {

   525     return STATIC_CAST(CNotepadListDialog*, 

   526         aThisPtr)->DoHandleEnvironmentChangedL();

   527     }

   528 

   529 // -----------------------------------------------------------------------------

   530 // CNotepadListDialog::DoHandleEnvironmentChangedL

   531 //

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

   533 // HandleDateChanged seems to be called.

   534 // To avoid calling ForceListSync at the first callback,

   535 // we use a flag ENotepadEverEnvironmentChanged.

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

   537 // ForceListSync is blocked by condition 

   538 //   ( iFlags & ENotepadEverEnvironmentChanged )

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

   540 //

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

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

   543 // -----------------------------------------------------------------------------

   544 //

   545 TInt CNotepadListDialog::DoHandleEnvironmentChangedL()

   546     {

   547     iClockValueChange = ((iEnvironmentChangeNotifier->Change() 

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

   549             

   550     if ( ( iFlags & ENotepadEverEnvironmentChanged ) && iClockValueChange)

   551         {

   552         iModel->HandleDateChangedL((iFlags & ENotepadIsBackground));

   553         }

   554     iFlags |= ENotepadEverEnvironmentChanged;

   555     

   556     return TRUE; // callback should be called again.

   557     }

   558 

   559 // -----------------------------------------------------------------------------

   560 // CNotepadListDialog::SaveCurrentAndSelectionsL

   561 // does nothing if already saved.

   562 // -----------------------------------------------------------------------------

   563 //

   564 void CNotepadListDialog::SaveCurrentAndSelectionsL()

   565     {

   566     if ( iSavedKey != KNotepadInvalidKeyId ) // ie. already saved

   567         {

   568         return;

   569         }

   570     if ( iModel->MdcaCount() == 0 ) // empty

   571         {

   572         ClearSavedCurrentAndSelections();

   573         }

   574     else

   575         {

   576         // save current

   577         //

   578         TInt currentIndex( iListBox->CurrentItemIndex() );

   579         iSavedKey = iModel->Key(currentIndex);

   580         iSavedKeysAboveCurrent.Reset();

   581         for ( TInt i(0); i < currentIndex; i++ )

   582             {

   583             User::LeaveIfError(

   584                 iSavedKeysAboveCurrent.Append(iModel->Key(i)));

   585             }

   586         // save selections

   587         //

   588         CreateKeyArrayOfSelectionsL();

   589         }

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // CNotepadListDialog::RestoreCurrentAndSelectionsL

   594 // 

   595 // The case **1** is posible, eg. in following case;

   596 //  1. Launch Notepad and suspend it by Application key in empty List mode,

   597 //  2. Save a certain file as a memo using NpdTest.app,

   598 //  3. Launch Pinboard and select "Write a note",

   599 //  then crash (if **1** were not done).

   600 //

   601 // Why this function TRAP RestoreSelectionsL?

   602 //  1. We must do SetDisableRedraw(EFalse) even if LEAVE,

   603 //  2. We must do ClearSavedCurrentAndSelections even if LEAVE.

   604 // -----------------------------------------------------------------------------

   605 //

   606 void CNotepadListDialog::RestoreCurrentAndSelectionsL()

   607     {

   608     const TBool isEmpty( iModel->MdcaCount() == 0 );

   609     if ( !isEmpty && iListBox->CurrentItemIndex() < 0 ) // **1**

   610         {

   611         iListBox->SetCurrentItemIndex(0);

   612         }

   613     if ( iSavedKey != KNotepadInvalidKeyId ) // ie. has saved

   614         {

   615         TInt err(KErrNone);

   616         if ( !isEmpty ) // not empty

   617             {

   618             TBool redrawDisabledByThisFunction(EFalse);

   619             if ( !iListBox->View()->RedrawDisabled() )

   620                 {

   621                 iListBox->View()->SetDisableRedraw(ETrue);

   622                 redrawDisabledByThisFunction = ETrue;

   623                 }

   624             RestoreCurrent();

   625             AdjustTopItemIfNeed();

   626 

   627             TRAP(err, RestoreSelectionsL();); // LEAVE should be postponed

   628             if ( redrawDisabledByThisFunction )

   629                 {

   630                 iListBox->View()->SetDisableRedraw(EFalse);

   631                 }

   632             }

   633         ClearSavedCurrentAndSelections();

   634         if (iNeedSave)

   635 			{

   636 			SaveCurrentAndSelectionsL();

   637 			iNeedSave = EFalse;

   638 			}

   639         User::LeaveIfError(err);

   640   /*      iListBox->ScrollBarFrame()->MoveVertThumbTo(

   641             iListBox->CurrentItemIndex());*/

   642         }

   643     }

   644 

   645 // -----------------------------------------------------------------------------

   646 // CNotepadListDialog::RestoreCurrent

   647 // -----------------------------------------------------------------------------

   648 //

   649 void CNotepadListDialog::RestoreCurrent()

   650     {

   651     __ASSERT_DEBUG( iModel->MdcaCount() > 0, 

   652         Panic(ENotepadLibraryPanicNoItem) );

   653     TInt resultIndex( iModel->IndexOf( iSavedKey ) );

   654     if ( resultIndex == KNotepadModelInvalidIndex ) // not found

   655         {

   656         const TInt savedIndex( iSavedKeysAboveCurrent.Count() );

   657         if ( savedIndex == 0 )

   658             {

   659             resultIndex = 0;

   660             }

   661         else

   662             {

   663             for ( TInt i(savedIndex - 1); i >= 0; --i )

   664                 {

   665                 TInt index( iModel->IndexOf(iSavedKeysAboveCurrent[i]) );

   666                 if ( index == KNotepadModelInvalidIndex || 

   667                     index >= savedIndex )

   668                     {

   669                     //the key no longer exists above current

   670                     iSavedKeysAboveCurrent.Remove(i);

   671                     }

   672                 }

   673             resultIndex = iSavedKeysAboveCurrent.Count();

   674             if ( resultIndex >= iModel->MdcaCount() )

   675                 {

   676                 resultIndex = iModel->MdcaCount() - 1; // assert "count>0"

   677                 }

   678             }

   679         }

   680     iListBox->View()->CalcBottomItemIndex(); // to avoid crash in next line

   681     iListBox->SetCurrentItemIndex( resultIndex );

   682     }

   683 

   684 // -----------------------------------------------------------------------------

   685 // CNotepadListDialog::RestoreSelectionsL

   686 // -----------------------------------------------------------------------------

   687 //

   688 void CNotepadListDialog::RestoreSelectionsL()

   689     {

   690     iListBox->ClearSelection();

   691     for ( TInt i(0); i < iSavedSelectedKeys.Count() ; i++ )

   692         {

   693         TInt selectedIndex( iModel->IndexOf(iSavedSelectedKeys[i]) );

   694         if ( selectedIndex != KNotepadModelInvalidIndex ) // found

   695             {

   696             iListBox->View()->SelectItemL(selectedIndex);

   697             }

   698         }

   699     }

   700 

   701 // -----------------------------------------------------------------------------

   702 // CNotepadListDialog::ClearSavedCurrentAndSelections

   703 // -----------------------------------------------------------------------------

   704 //

   705 void CNotepadListDialog::ClearSavedCurrentAndSelections()

   706     {

   707     iSavedKey = KNotepadPseudoKeyIdForNewNote;

   708     iSavedKeysAboveCurrent.Reset();

   709     iSavedKeysAboveCurrent.Compress();

   710     iSavedSelectedKeys.Reset();

   711     iSavedSelectedKeys.Compress();

   712     }

   713 

   714 // -----------------------------------------------------------------------------

   715 // CNotepadListDialog::AdjustTopItemIfNeed

   716 // -----------------------------------------------------------------------------

   717 //

   718 void CNotepadListDialog::AdjustTopItemIfNeed()

   719     {

   720     __ASSERT_DEBUG( iModel->MdcaCount() > 0, 

   721         Panic(ENotepadLibraryPanicNoItem) );

   722     if ( iFlags & ENotepadItemAdded )

   723         {

   724         iFlags &= ~ENotepadItemAdded;

   725         const TInt count( iModel->MdcaCount() );

   726         const TInt index( iListBox->CurrentItemIndex() );

   727         const TInt lines( iListBox->View()->NumberOfItemsThatFitInRect(

   728             iListBox->View()->ViewRect() ) );

   729         iListBox->View()->SetTopItemIndex( 

   730             (count - lines) >= index ? index :

   731                 ( count > lines ? count - lines : 0 ) );

   732         }

   733     }

   734 

   735 // -----------------------------------------------------------------------------

   736 // CNotepadListDialog::AvoidSyncing

   737 // -----------------------------------------------------------------------------

   738 //

   739 TBool CNotepadListDialog::AvoidSyncing() const

   740     {

   741         return (((iEditorDialog != NULL) && iEditorDialog->IsFocused()) || iModel->IsDeleting()

   742         || (LevelOfActiveScheduler() != iBaseLevelOfActiveScheduler)

   743         || ((iFlags & ENotepadIsBackground) && !iClockValueChange)

   744         || (iBaseAppUi != iEikonEnv->EikAppUi()));

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CNotepadListDialog::DoHandleViewEventL

   749 //

   750 // When launching Notepad application, 

   751 // the event TVwsViewEvent::EVwsActivateView occurs

   752 // but we have nothing to do at that time 

   753 // (because all operations are for resuming).

   754 // In order to avoid doing such needless operations,

   755 // we use the flag ENotepadEverViewDeactivated which denotes

   756 // whether the view has deactivated.

   757 // This flag is set first time TVwsViewEvent::EVwsDeactivateView,

   758 // and will never be cleared in this object's lifetime.

   759 // -----------------------------------------------------------------------------

   760 //

   761 void CNotepadListDialog::DoHandleViewEventL(const TVwsViewEvent& aEvent)

   762     {

   763     TLocale local;

   764     switch ( aEvent.iEventType )

   765         {

   766         case TVwsViewEvent::EVwsActivateView:

   767             iFlags &= ~ENotepadIsBackground;

   768             if ( iFlags & ENotepadEverViewDeactivated )

   769                 {

   770                 iCurrentTimeFormat = local.TimeFormat();

   771                 if ( !AvoidSyncing()||( iCurrentTimeFormat != iPreTimeFormat )||(iModel->ItemArrayFlags())& CNotepadModel::ENotepadRequireDbViewUpdate )

   772                     {

   773                     iModel->SetItemArrayFlags();

   774                     iModel->SyncL(EFalse);

   775                     iNeedSave = ETrue;

   776                     if (iEditorFlag)

   777                     {

   778                     RestoreCurrentAndSelectionsL();

   779                     }                    

   780                     if( iCurrentTimeFormat!= iPreTimeFormat )

   781                     	{

   782                     	break;

   783                     	}

   784                     iListBox->DrawNow();

   785                     }

   786                 }

   787             break;

   788         case TVwsViewEvent::EVwsDeactivateView:

   789             iPreTimeFormat = local.TimeFormat();

   790             iFlags |= ENotepadIsBackground;

   791             iFlags |= ENotepadEverViewDeactivated;

   792            		if ( !iEditorDialog 

   793                 && LevelOfActiveScheduler() == iBaseLevelOfActiveScheduler

   794                 && iBaseAppUi == iEikonEnv->EikAppUi() //SendUi isn't running

   795                 && !iModel->IsDeleting() )

   796                 {

   797                 ClearSavedCurrentAndSelections();

   798                 if ( !iSendingEmail )

   799                 	{

   800 					SaveCurrentAndSelectionsL();

   801                 	}

   802 				iSendingEmail = EFalse;

   803                 }

   804             break;

   805         default:

   806             break;

   807         }

   808     }

   809 

   810 // -----------------------------------------------------------------------------

   811 // CNotepadListDialog::HandleNotepadModelEventL

   812 // -----------------------------------------------------------------------------

   813 //

   814 void CNotepadListDialog::HandleNotepadModelEventL(

   815     TEvent aEvent, 

   816     TInt aParam )

   817     {

   818     switch ( aEvent )

   819         {

   820         case EDatabaseChanged:

   821             if ( !AvoidSyncing() )

   822                 {

   823                 if(iClockValueChange)

   824                 	{

   825                 	iModel->SetItemArrayFlags();

   826                 	iClockValueChange = EFalse;

   827                 	}

   828                 iModel->SyncL(EFalse);

   829                 }

   830             break;

   831         case EAbortDeletion:

   832             // no need for DialogDismissedL, so no need for ProcessFinishedL

   833             delete iProgressDialog;

   834             iProgressDialog = NULL;

   835             break;

   836         case ECompleteDeletion:

   837             if ( iProgressDialog )

   838                 {

   839                 iProgressDialog->ProcessFinishedL();

   840                 }

   841             break;

   842         case EProgressDeletion:

   843             if ( iProgressDialog && aParam > 0 )

   844                 {

   845                 iProgressDialog->IncrementL(aParam);

   846                 }

   847             break;

   848         case EStartItemArrayChange:

   849             SaveCurrentAndSelectionsL();

   850             break;

   851         case EAbortItemArrayChange:

   852             iListBox->View()->SetDisableRedraw(EFalse);

   853             iListBox->Reset();

   854             iListBox->DrawDeferred();

   855             //MSK  			

   856 			MiddleSoftKeyL();

   857             break;

   858         case EProgressItemArrayChange:

   859             // skip RestoreCurrentAndSelectionsL

   860             iListBox->View()->SetDisableRedraw(EFalse);

   861             iListBox->DrawDeferred();

   862             break;

   863         case ECompleteItemArrayChange:

   864             iListBox->HandleItemRemovalL();

   865             iNeedSave = ETrue;

   866             RestoreCurrentAndSelectionsL();

   867             iListBox->View()->SetDisableRedraw(EFalse);

   868             iListBox->DrawNow();

   869 			//MSK  			

   870 			MiddleSoftKeyL();

   871             break;

   872         default:

   873             break;

   874         }

   875     }

   876 

   877 // -----------------------------------------------------------------------------

   878 // CNotepadListDialog::DynInitMenuPaneL

   879 // from MEikMenuObserver

   880 // -----------------------------------------------------------------------------

   881 //

   882 void CNotepadListDialog::DynInitMenuPaneL(

   883     TInt aResourceId,

   884     CEikMenuPane* aMenuPane )

   885     {

   886     __ASSERT_DEBUG( aResourceId > 0, 

   887         Panic(ENotepadLibraryPanicNoMenuResource) );

   888     __ASSERT_DEBUG( aMenuPane, Panic(ENotepadLibraryPanicNullMenuPane) );

   889     __ASSERT_DEBUG( iListBox, Panic(ENotepadLibraryPanicNullListControl) );

   890     __ASSERT_DEBUG( iModel, Panic(ENotepadLibraryPanicNoModel) );

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

   892 		{

   893 		return;

   894 		}

   895 	

   896     ClearSavedCurrentAndSelections();

   897     SaveCurrentAndSelectionsL();

   898     iModel->SyncL(EFalse);

   899     CNotepadDialogBase::DynInitMenuPaneL( aResourceId, aMenuPane );

   900     

   901     TInt memoCount = iModel->MdcaCount();

   902     if ( IsNoteListDialog() )

   903         {

   904         memoCount = memoCount - KNumberOfFixedItem;

   905         }

   906     

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

   908 	TInt index;

   909 	switch (aResourceId )

   910         {

   911         case R_SENDUI_MENU:

   912             index = 2;

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

   914             break;

   915         case R_NOTEPAD_LIST_MENU_SECOND:

   916             if( !(iFlags & ENotepadMenuByOkKey) || (memoCount && !markCount))

   917             	{

   918             	iServiceHandler->InitializeMenuPaneL( *aMenuPane, aResourceId, ECmdLast, iServiceHandler->InParamListL() );	

   919             	}

   920             	if ( iFlags & ENotepadMenuByOkKey )

   921                 {

   922                	if ( !memoCount || markCount )

   923                		{

   924                		  aMenuPane->DeleteMenuItem(ECmdAiwPlaceholder);

   925                		}

   926                 }

   927             // go through into next case

   928         case R_NOTEPAD_TEMPLATE_LIST_MENU_SECOND:

   929         	{

   930 			if(!FeatureManager::FeatureSupported(KFeatureIdHelp))

   931 				{

   932 				aMenuPane->DeleteMenuItem(EAknCmdHelp);

   933 				}

   934             if ( iFlags & ENotepadMenuByOkKey )

   935                 {

   936                	if ( !memoCount || markCount )

   937                		{

   938                		if( markCount )

   939                			aMenuPane->DeleteMenuItem(ENotepadCmdAdd);

   940                		}

   941 				if(FeatureManager::FeatureSupported(KFeatureIdHelp))

   942 					{

   943                	aMenuPane->DeleteMenuItem(EAknCmdHelp);

   944 					}

   945                	aMenuPane->DeleteMenuItem(EAknCmdExit);

   946                 }

   947         	}

   948             break;

   949         case R_NOTEPAD_LIST_MENU_FIRST:

   950         case R_NOTEPAD_TEMPLATE_LIST_MENU_FIRST:

   951             {

   952             if ( IsNotepad() )

   953                 {

   954                 if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

   955                     {

   956                     // Initiliaze menu

   957                     if ( memoCount )

   958                         {

   959                         iServiceHandler->InitializeMenuPaneL( *aMenuPane,

   960                                                               aResourceId,

   961                                                               ENotepadCmdPrint,

   962                                                               iServiceHandler->InParamListL()

   963                                                             );

   964                         }

   965                         else

   966                         // If listbox is empty, delete Print AIW menu item.

   967                         {

   968                         aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

   969                         }

   970                     } // KFeatureIdFfEnablePrintingFramework

   971                 else

   972                     {

   973                     aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

   974                     } 

   975                 }

   976             TInt currIndex = iListBox->CurrentItemIndex();

   977             TKeyArrayFix itemKey(0,ECmpTUint);

   978             TInt ignore;

   979             TInt itemMarked = iListBox->SelectionIndexes()->Find( currIndex, itemKey, ignore );

   980 			

   981             if ( memoCount > 0 && 

   982                 ( markCount == 0 || IsNotepad() || IsTemplates()) )

   983                 {

   984                 // this must preceed DeleteMenuItem(ENotepadCmdOpen)

   985                 InsertSendMenuItemAfterL( *iSendUi, *aMenuPane, 

   986                     ENotepadCmdOpen );

   987                 }

   988 				

   989             if ( memoCount == 0 )

   990                 {

   991                 aMenuPane->DeleteMenuItem( ENotepadCmdDelete );

   992                 }

   993 				

   994             //delete 'Open' item from Option list at the following situations:

   995             //no memo,have item marked,user select the 'New note'

   996             if ( ( memoCount == 0 ) || ( markCount >= 1 ) || 

   997                     ( ( currIndex == 0 ) && IsNotepad() ) )

   998                 {

   999                 // this must after InsertSendMenuItemAfterL

  1000                 aMenuPane->DeleteMenuItem( ENotepadCmdOpen );

  1001                 }

  1002 				

  1003             if ( markCount >= 1 && IsNoteListDialog() && ( memoCount > 0 ) )

  1004                 {

  1005                 aMenuPane->SetItemSpecific( ENotepadCmdSend, EFalse );

  1006                 aMenuPane->SetItemSpecific( ENotepadCmdDelete, EFalse );

  1007                 }

  1008             

  1009             if ( IsTemplateListDialog() && ( memoCount > 0 ) )

  1010                 {

  1011                 aMenuPane->SetItemSpecific( ENotepadCmdSend, ETrue );

  1012                 if ( markCount >= 1 )

  1013                     {

  1014                     aMenuPane->SetItemDimmed( ENotepadCmdSend, ETrue );

  1015                     }

  1016                  }

  1017             

  1018             if ( iListBox->CurrentItemIndex() == 0 && IsNotepad() && memoCount > 0 && markCount == 0 )

  1019 				{                    

  1020 				aMenuPane->SetItemDimmed( ENotepadCmdDelete, ETrue );				 

  1021 				aMenuPane->SetItemDimmed( ENotepadCmdSend, ETrue );				 

  1022 				}

  1023 			}

  1024             break;

  1025         default:

  1026 			{

  1027 			if ( IsTemplates() )

  1028 				{

  1029 				AknSelectionService::HandleMarkableListDynInitMenuPane(

  1030 						aResourceId, aMenuPane, iListBox );				

  1031 				}

  1032 			else

  1033 				{			

  1034 			    HandleMarkListDynInitMenuPane( aResourceId, aMenuPane, iListBox );

  1035 				}	

  1036 			break;

  1037 			}

  1038 		}

  1039     }

  1040     

  1041 // -----------------------------------------------------------------------------

  1042 // CNotepadListDialog::DynInitMenuBarL

  1043 // from MEikMenuObserver

  1044 // -----------------------------------------------------------------------------

  1045 //    

  1046 void CNotepadListDialog::DynInitMenuBarL(

  1047     TInt aResourceId,

  1048     CEikMenuBar* aMenuBar )

  1049     

  1050 {

  1051 	

  1052 	__ASSERT_DEBUG( aResourceId > 0, 

  1053         Panic(ENotepadLibraryPanicNoMenuResource) );

  1054     __ASSERT_DEBUG( aMenuBar, Panic(ENotepadLibraryPanicNoMenuResource) );

  1055    

  1056     if (iMskFlag)

  1057     {

  1058     	

  1059     aMenuBar->SetMenuType(CEikMenuBar::EMenuContext);

  1060     iMskFlag= EFalse;

  1061     }

  1062     else

  1063     {

  1064     	aMenuBar->SetMenuType(CEikMenuBar::EMenuOptions);

  1065     }

  1066     

  1067 	

  1068 }

  1069 

  1070 // -----------------------------------------------------------------------------

  1071 // CNotepadListDialog::ProcessCommandL

  1072 // from MEikCommandObserver

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 void CNotepadListDialog::ProcessCommandL(TInt aCommandId)

  1076     {

  1077     HideMenu();

  1078     switch ( aCommandId )

  1079         {

  1080         case ENotepadCmdOpen: // Open memo

  1081             OnCmdOpenL( iListBox->CurrentItemIndex() );

  1082             break;

  1083         case ENotepadCmdAdd:

  1084            OnCmdAddL();

  1085             break;

  1086         case ENotepadCmdDelete:

  1087             OnCmdDeleteL();

  1088             break;

  1089         case ENotepadCmdSend:

  1090         	OnCmdSendL(aCommandId);

  1091         	break;

  1092 		case EAknMarkAll:

  1093 			{

  1094 			if ( IsNotepad() )

  1095 				{

  1096 				iListBox->ClearSelection();

  1097 				TInt num = iListBox->Model()->NumberOfItems();

  1098 				if ( num < 2 )

  1099 					return;

  1100 				TInt ii = 0;

  1101 				CArrayFixFlat<TInt>* array = new (ELeave) CArrayFixFlat<TInt> (

  1102 						20 );

  1103 				CleanupStack::PushL(array);

  1104 				array->SetReserveL(num);

  1105 				for ( ii = 1; ii < num; ii++ )

  1106 					{

  1107 					array->AppendL( ii );

  1108 					}

  1109 				iListBox->SetSelectionIndexesL( array );

  1110 				CleanupStack::PopAndDestroy(); //array

  1111 				break;

  1112 				}

  1113 			}

  1114         default:

  1115             {

  1116             const TInt aiwServiceCmd( iServiceHandler ? iServiceHandler->ServiceCmdByMenuCmd( aCommandId ) : 0 );                

  1117             if ( aiwServiceCmd == KAiwCmdPrint )

  1118                 {

  1119                 CAiwGenericParamList& inParams = iServiceHandler->InParamListL();

  1120 

  1121                 // Note index

  1122                 TAiwGenericParam noteParam( EGenericParamNoteItem );

  1123                 const TInt32 noteKey = iModel->Key( iListBox->CurrentItemIndex() );

  1124                 noteParam.Value().Set( noteKey );

  1125                 inParams.AppendL( noteParam );

  1126 

  1127                 // Application uid

  1128                 const TUid uid( KUidNotepad ); // Notepad Uid3

  1129                 TAiwGenericParam uidParam( EGenericParamApplication );

  1130                 uidParam.Value().Set( uid );

  1131                 inParams.AppendL( uidParam );

  1132 

  1133                 // Execute service command with given parameters