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 

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

    69 

    70 // -----------------------------------------------------------------------------

    71 // CNotepadListDialog::NewL

    72 // Constructor.

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

    74 //

    75 EXPORT_C CNotepadListDialog* CNotepadListDialog::NewL(

    76     TInt aResId,             // Resource Id of type NOTEPAD_LIST_DIALOG

    77     CEikDialog** aSelfPtr )

    78     {

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

    80     self->iSelfPtr = aSelfPtr;

    81     CleanupStack::PushL(self);

    82     TResourceReader rr;

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

    84     self->ConstructL( rr );

    85     CleanupStack::PopAndDestroy(); // rr

    86     CleanupStack::Pop(); // self

    87     return self;

    88     }

    89 

    90 // -----------------------------------------------------------------------------

    91 // CNotepadListDialog::~CNotepadListDialog

    92 // Destructor.

    93 //

    94 // In destructor of CNotepadEditorDialog, 

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

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

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

    98 //

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

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

   101 // Because the focus is changed in deleting iProgressDialog 

   102 // (caused by RemoveFromStack).

   103 // -----------------------------------------------------------------------------

   104 //

   105 EXPORT_C CNotepadListDialog::~CNotepadListDialog()

   106     {

   107     delete iIdle;

   108     delete iProgressDialog; // *1*

   109     delete iEditorDialog;

   110     if ( iFlags & ENotepadObserveView )

   111         {

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

   113         }

   114     delete iModel;

   115     delete iSendUi;

   116     iSavedSelectedKeys.Close();

   117     iSavedKeysAboveCurrent.Close();

   118     delete iEnvironmentChangeNotifier;

   119     if ( iServiceHandler )

   120     	{

   121     	    	

   122 		delete iServiceHandler;

   123 		iServiceHandler = NULL;

   124     	}

   125     }

   126 

   127 // -----------------------------------------------------------------------------

   128 // CNotepadListDialog::EditByKeyL

   129 // Called from CNotepadAppUi.

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

   131 //

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

   133     {

   134     __ASSERT_DEBUG( IsNotepad(), 

   135         Panic(ENotepadLibraryPanicOnlySupportedInNotepad) );

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

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

   138        	&& !iModel->IsDeleting() )

   139         {

   140         DoEditByKeyL(aKey);

   141         }

   142     }

   143 

   144 // -----------------------------------------------------------------------------

   145 // CNotepadListDialog::SaveL

   146 // -----------------------------------------------------------------------------

   147 //

   148 EXPORT_C void CNotepadListDialog::SaveL()

   149     {

   150     if ( iEditorDialog )

   151         {

   152         iEditorDialog->SaveOnExitL(EFalse);

   153         }

   154     }

   155 

   156 // -----------------------------------------------------------------------------

   157 // CNotepadListDialog::HandleEditorExitL

   158 // This function is called from CNotepadEditorDialog.

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

   160 //

   161 void CNotepadListDialog::HandleEditorExitL(

   162     TInt aStatOfSave, 

   163     const TInt aKey,

   164     const TBool aEagerSync )

   165     {

   166     	iEditorFlag= EFalse;

   167     if ( aKey != KNotepadPseudoKeyIdForNewNote )

   168         {

   169         iSavedKey = aKey;

   170         }

   171     if ( aStatOfSave == CNotepadModel::ENotepadModelRowAdded )

   172         {

   173         iFlags |= ENotepadItemAdded;

   174         }

   175     else 

   176         {

   177         iFlags &= ~ENotepadItemAdded;

   178         }

   179     if ( aEagerSync )

   180         {

   181         if(iClockValueChange)

   182         	{

   183         	iModel->SetItemArrayFlags();

   184         	iClockValueChange = EFalse;

   185         	}

   186         iModel->SyncL(EFalse);

   187         RestoreCurrentAndSelectionsL();

   188         DrawNow();

   189         }

   190     if (aStatOfSave == CNotepadModel::ENotepadModelRowDeleted)

   191     	{

   192     	iListBox->HandleItemRemovalL();

   193     	DrawNow();

   194     	}

   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     if ( iModel->MdcaCount() == 0 ) // this is posible when clear key

   359         {

   360         return;

   361         }

   362     ClearSavedCurrentAndSelections();

   363     SaveCurrentAndSelectionsL();

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

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

   366     if ( ConfirmDeleteL( deleteCount ) )

   367         {

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

   369         //

   370         if ( markCount > 0 ? 

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

   372             iModel->MdcaCount() > 0 )

   373             {

   374             // assert "deleteCount >= 1"

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

   376                 { //**A**

   377                 // Both Notepad and MCE specs require ProgressDialog

   378                 // in deleting multiple items.

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

   380                 //

   381                 CreateProgressDialogL(deleteCount,

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

   383                     R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE :

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

   385                         R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATES :

   386                         0 )); // default label for Notepad

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

   388                 }

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

   390                 { //**B**

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

   392                 //

   393                 RArray<TInt> keys(1);

   394                 CleanupClosePushL(keys);

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

   396                 CreateProgressDialogL( deleteCount, 

   397                     R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE );

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

   399                 CleanupStack::PopAndDestroy();// keys

   400                 }

   401             else 

   402                 { //**C**

   403                 // Notepad spec doesn't require ProgressDialog 

   404                 // in deleting a single item

   405                 //

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

   407                     iSavedSelectedKeys[0] );

   408                 }

   409             }

   410         }

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

   412     }

   413 

   414 // -----------------------------------------------------------------------------

   415 // CNotepadListDialog::OnCmdSendL

   416 // -----------------------------------------------------------------------------

   417 //

   418 void CNotepadListDialog::OnCmdSendL(TInt aCommandId)

   419     {

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

   421         {

   422     	  return;

   423         }    

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

   425         {

   426         ClearSavedCurrentAndSelections();

   427         SaveCurrentAndSelectionsL();

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

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

   430         RestoreCurrentAndSelectionsL();

   431         //RestoreCurrent();

   432         TUid EmailUid = {0x10001028};

   433         if ( serviceUid == EmailUid )

   434         	{

   435         	iSendingEmail = ETrue;

   436         	}

   437        

   438         }

   439     else

   440         {

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

   442         CleanupStack::PushL(text);

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

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

   445         CleanupStack::PopAndDestroy(); // text

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

   447         RestoreCurrentAndSelectionsL();

   448         }

   449     }

   450 

   451 // -----------------------------------------------------------------------------

   452 // CNotepadListDialog::CreateProgressDialogL

   453 // -----------------------------------------------------------------------------

   454 //

   455 void CNotepadListDialog::CreateProgressDialogL(

   456     const TInt aCount,

   457     const TInt aLabelResId )

   458     {

   459     __ASSERT_DEBUG( aCount >= 1, 

   460         Panic(ENotepadLibraryPanicInvalidFinalValueOfProgressNote) );

   461     delete iProgressDialog;

   462     iProgressDialog = NULL;

   463     iProgressDialog = new(ELeave) CNotepadProgressDialog(

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

   465       		

   466     iProgressDialog->SetMopParent(this);

   467         

   468     iProgressDialog->PrepareLC(R_NOTEPAD_DELETE_PROGRESS_NOTE);    

   469         

   470     iProgressDialog->PrepareL(aCount, aLabelResId);

   471     iProgressDialog->ProgressInfo()->SetFinalValue( 

   472         aLabelResId == 0 ? 

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

   474             : aCount );

   475      iProgressDialog->SetCallback(this);   

   476     iProgressDialog->RunLD();

   477     }

   478 

   479 // -----------------------------------------------------------------------------

   480 // CNotepadListDialog::DoEditByKeyL

   481 // -----------------------------------------------------------------------------

   482 //

   483 void CNotepadListDialog::DoEditByKeyL(const TInt aKey)

   484     {

   485     iModel->SyncL(EFalse);

   486     if ( iEditorDialog )

   487         {

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

   489         }

   490 	else if ( aKey != KNotepadPseudoKeyIdForNewNote 

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

   492 		{

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

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

   495 		}

   496     else

   497         {

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

   499        	OnCmdAddL();

   500         }

   501     }

   502 

   503 // -----------------------------------------------------------------------------

   504 // CNotepadListDialog::HandleEnvironmentChangedL

   505 // private static function.

   506 // -----------------------------------------------------------------------------

   507 //

   508 TInt CNotepadListDialog::HandleEnvironmentChangedL( TAny* aThisPtr )

   509     {

   510     return STATIC_CAST(CNotepadListDialog*, 

   511         aThisPtr)->DoHandleEnvironmentChangedL();

   512     }

   513 

   514 // -----------------------------------------------------------------------------

   515 // CNotepadListDialog::DoHandleEnvironmentChangedL

   516 //

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

   518 // HandleDateChanged seems to be called.

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

   520 // we use a flag ENotepadEverEnvironmentChanged.

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

   522 // ForceListSync is blocked by condition 

   523 //   ( iFlags & ENotepadEverEnvironmentChanged )

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

   525 //

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

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

   528 // -----------------------------------------------------------------------------

   529 //

   530 TInt CNotepadListDialog::DoHandleEnvironmentChangedL()

   531     {

   532     iClockValueChange = ((iEnvironmentChangeNotifier->Change() 

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

   534             

   535     if ( ( iFlags & ENotepadEverEnvironmentChanged ) && iClockValueChange)

   536         {

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

   538         }

   539     iFlags |= ENotepadEverEnvironmentChanged;

   540     

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

   542     }

   543 

   544 // -----------------------------------------------------------------------------

   545 // CNotepadListDialog::SaveCurrentAndSelectionsL

   546 // does nothing if already saved.

   547 // -----------------------------------------------------------------------------

   548 //

   549 void CNotepadListDialog::SaveCurrentAndSelectionsL()

   550     {

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

   552         {

   553         return;

   554         }

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

   556         {

   557         ClearSavedCurrentAndSelections();

   558         }

   559     else

   560         {

   561         // save current

   562         //

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

   564         iSavedKey = iModel->Key(currentIndex);

   565         iSavedKeysAboveCurrent.Reset();

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

   567             {

   568             User::LeaveIfError(

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

   570             }

   571         // save selections

   572         //

   573         CreateKeyArrayOfSelectionsL();

   574         }

   575     }

   576 

   577 // -----------------------------------------------------------------------------

   578 // CNotepadListDialog::RestoreCurrentAndSelectionsL

   579 // 

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

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

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

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

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

   585 //

   586 // Why this function TRAP RestoreSelectionsL?

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

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

   589 // -----------------------------------------------------------------------------

   590 //

   591 void CNotepadListDialog::RestoreCurrentAndSelectionsL()

   592     {

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

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

   595         {

   596         iListBox->SetCurrentItemIndex(0);

   597         }

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

   599         {

   600         TInt err(KErrNone);

   601         if ( !isEmpty ) // not empty

   602             {

   603             TBool redrawDisabledByThisFunction(EFalse);

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

   605                 {

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

   607                 redrawDisabledByThisFunction = ETrue;

   608                 }

   609             RestoreCurrent();

   610             AdjustTopItemIfNeed();

   611 

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

   613             if ( redrawDisabledByThisFunction )

   614                 {

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

   616                 }

   617             }

   618         ClearSavedCurrentAndSelections();

   619         if (iNeedSave)

   620 			{

   621 			SaveCurrentAndSelectionsL();

   622 			iNeedSave = EFalse;

   623 			}

   624         User::LeaveIfError(err);

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

   626             iListBox->CurrentItemIndex());*/

   627         }

   628     }

   629 

   630 // -----------------------------------------------------------------------------

   631 // CNotepadListDialog::RestoreCurrent

   632 // -----------------------------------------------------------------------------

   633 //

   634 void CNotepadListDialog::RestoreCurrent()

   635     {

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

   637         Panic(ENotepadLibraryPanicNoItem) );

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

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

   640         {

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

   642         if ( savedIndex == 0 )

   643             {

   644             resultIndex = 0;

   645             }

   646         else

   647             {

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

   649                 {

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

   651                 if ( index == KNotepadModelInvalidIndex || 

   652                     index >= savedIndex )

   653                     {

   654                     //the key no longer exists above current

   655                     iSavedKeysAboveCurrent.Remove(i);

   656                     }

   657                 }

   658             resultIndex = iSavedKeysAboveCurrent.Count();

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

   660                 {

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

   662                 }

   663             }

   664         }

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

   666     iListBox->SetCurrentItemIndex( resultIndex );

   667     }

   668 

   669 // -----------------------------------------------------------------------------

   670 // CNotepadListDialog::RestoreSelectionsL

   671 // -----------------------------------------------------------------------------

   672 //

   673 void CNotepadListDialog::RestoreSelectionsL()

   674     {

   675     iListBox->ClearSelection();

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

   677         {

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

   679         if ( selectedIndex != KNotepadModelInvalidIndex ) // found

   680             {

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

   682             }

   683         }

   684     }

   685 

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

   687 // CNotepadListDialog::ClearSavedCurrentAndSelections

   688 // -----------------------------------------------------------------------------

   689 //

   690 void CNotepadListDialog::ClearSavedCurrentAndSelections()

   691     {

   692     iSavedKey = KNotepadPseudoKeyIdForNewNote;

   693     iSavedKeysAboveCurrent.Reset();

   694     iSavedKeysAboveCurrent.Compress();

   695     iSavedSelectedKeys.Reset();

   696     iSavedSelectedKeys.Compress();

   697     }

   698 

   699 // -----------------------------------------------------------------------------

   700 // CNotepadListDialog::AdjustTopItemIfNeed

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

   702 //

   703 void CNotepadListDialog::AdjustTopItemIfNeed()

   704     {

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

   706         Panic(ENotepadLibraryPanicNoItem) );

   707     if ( iFlags & ENotepadItemAdded )

   708         {

   709         iFlags &= ~ENotepadItemAdded;

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

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

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

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

   714         iListBox->View()->SetTopItemIndex( 

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

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

   717         }

   718     }

   719 

   720 // -----------------------------------------------------------------------------

   721 // CNotepadListDialog::AvoidSyncing

   722 // -----------------------------------------------------------------------------

   723 //

   724 TBool CNotepadListDialog::AvoidSyncing() const

   725     {

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

   727         || (LevelOfActiveScheduler() != iBaseLevelOfActiveScheduler)

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

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

   730     }

   731 

   732 // -----------------------------------------------------------------------------

   733 // CNotepadListDialog::DoHandleViewEventL

   734 //

   735 // When launching Notepad application, 

   736 // the event TVwsViewEvent::EVwsActivateView occurs

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

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

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

   740 // we use the flag ENotepadEverViewDeactivated which denotes

   741 // whether the view has deactivated.

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

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

   744 // -----------------------------------------------------------------------------

   745 //

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

   747     {

   748     TLocale local;

   749     switch ( aEvent.iEventType )

   750         {

   751         case TVwsViewEvent::EVwsActivateView:

   752             iFlags &= ~ENotepadIsBackground;

   753             if ( iFlags & ENotepadEverViewDeactivated )

   754                 {

   755                 iCurrentTimeFormat = local.TimeFormat();

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

   757                     {

   758                     iModel->SetItemArrayFlags();

   759                     iModel->SyncL(EFalse);

   760                     iNeedSave = ETrue;

   761                     if (iEditorFlag)

   762                     {

   763                     RestoreCurrentAndSelectionsL();

   764                     }                    

   765                     if( iCurrentTimeFormat!= iPreTimeFormat )

   766                     	{

   767                     	break;

   768                     	}

   769                     iListBox->DrawNow();

   770                     }

   771                 }

   772             break;

   773         case TVwsViewEvent::EVwsDeactivateView:

   774             iPreTimeFormat = local.TimeFormat();

   775             iFlags |= ENotepadIsBackground;

   776             iFlags |= ENotepadEverViewDeactivated;

   777            		if ( !iEditorDialog 

   778                 && LevelOfActiveScheduler() == iBaseLevelOfActiveScheduler

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

   780                 && !iModel->IsDeleting() )

   781                 {

   782                 ClearSavedCurrentAndSelections();

   783                 if ( !iSendingEmail )

   784                 	{

   785 					SaveCurrentAndSelectionsL();

   786                 	}

   787 				iSendingEmail = EFalse;

   788                 }

   789             break;

   790         default:

   791             break;

   792         }

   793     }

   794 

   795 // -----------------------------------------------------------------------------

   796 // CNotepadListDialog::HandleNotepadModelEventL

   797 // -----------------------------------------------------------------------------

   798 //

   799 void CNotepadListDialog::HandleNotepadModelEventL(

   800     TEvent aEvent, 

   801     TInt aParam )

   802     {

   803     switch ( aEvent )

   804         {

   805         case EDatabaseChanged:

   806             if ( !AvoidSyncing() )

   807                 {

   808                 if(iClockValueChange)

   809                 	{

   810                 	iModel->SetItemArrayFlags();

   811                 	iClockValueChange = EFalse;

   812                 	}

   813                 iModel->SyncL(EFalse);

   814                 }

   815             break;

   816         case EAbortDeletion:

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

   818             delete iProgressDialog;

   819             iProgressDialog = NULL;

   820             break;

   821         case ECompleteDeletion:

   822             if ( iProgressDialog )

   823                 {

   824                 iProgressDialog->ProcessFinishedL();

   825                 }

   826             break;

   827         case EProgressDeletion:

   828             if ( iProgressDialog && aParam > 0 )

   829                 {

   830                 iProgressDialog->IncrementL(aParam);

   831                 }

   832             break;

   833         case EStartItemArrayChange:

   834             SaveCurrentAndSelectionsL();

   835             break;

   836         case EAbortItemArrayChange:

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

   838             iListBox->Reset();

   839             iListBox->DrawDeferred();

   840             //MSK  			

   841 			MiddleSoftKeyL();

   842             break;

   843         case EProgressItemArrayChange:

   844             // skip RestoreCurrentAndSelectionsL

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

   846             iListBox->DrawDeferred();

   847             break;

   848         case ECompleteItemArrayChange:

   849             iListBox->HandleItemRemovalL();

   850             iNeedSave = ETrue;

   851             RestoreCurrentAndSelectionsL();

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

   853             iListBox->DrawNow();

   854 			//MSK  			

   855 			MiddleSoftKeyL();

   856             break;

   857         default:

   858             break;

   859         }

   860     }

   861 

   862 // -----------------------------------------------------------------------------

   863 // CNotepadListDialog::DynInitMenuPaneL

   864 // from MEikMenuObserver

   865 // -----------------------------------------------------------------------------

   866 //

   867 void CNotepadListDialog::DynInitMenuPaneL(

   868     TInt aResourceId,

   869     CEikMenuPane* aMenuPane )

   870     {

   871     __ASSERT_DEBUG( aResourceId > 0, 

   872         Panic(ENotepadLibraryPanicNoMenuResource) );

   873     __ASSERT_DEBUG( aMenuPane, Panic(ENotepadLibraryPanicNullMenuPane) );

   874     __ASSERT_DEBUG( iListBox, Panic(ENotepadLibraryPanicNullListControl) );

   875     __ASSERT_DEBUG( iModel, Panic(ENotepadLibraryPanicNoModel) );

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

   877 		{

   878 		return;

   879 		}

   880     iModel->SyncL(EFalse);

   881     CNotepadDialogBase::DynInitMenuPaneL( aResourceId, aMenuPane );

   882     const TInt memoCount( iModel->MdcaCount() );

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

   884     TInt index;

   885     switch ( aResourceId )

   886         {

   887         case R_SENDUI_MENU:

   888             index = 2;

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

   890             break;

   891         case R_NOTEPAD_LIST_MENU_SECOND:

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

   893             	{

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

   895             	}

   896             	if ( iFlags & ENotepadMenuByOkKey )

   897                 {

   898                	if ( !memoCount || markCount )

   899                		{

   900                		  aMenuPane->DeleteMenuItem(ECmdAiwPlaceholder);

   901                		}

   902                 }

   903             // go through into next case

   904         case R_NOTEPAD_TEMPLATE_LIST_MENU_SECOND:

   905         	{

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

   907 				{

   908 				aMenuPane->DeleteMenuItem(EAknCmdHelp);

   909 				}

   910             if ( iFlags & ENotepadMenuByOkKey )

   911                 {

   912                	if ( !memoCount || markCount )

   913                		{

   914                		if( markCount )

   915                			aMenuPane->DeleteMenuItem(ENotepadCmdAdd);

   916                		}

   917 				if(FeatureManager::FeatureSupported(KFeatureIdHelp))

   918 					{

   919                	aMenuPane->DeleteMenuItem(EAknCmdHelp);

   920 					}

   921                	aMenuPane->DeleteMenuItem(EAknCmdExit);

   922                 }

   923         	}

   924             break;

   925         case R_NOTEPAD_LIST_MENU_FIRST:

   926         case R_NOTEPAD_TEMPLATE_LIST_MENU_FIRST:

   927             {

   928             if ( IsNotepad() )

   929                 {

   930                 if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

   931                     {

   932                     // Initiliaze menu

   933                     if ( memoCount )

   934                         {

   935                         iServiceHandler->InitializeMenuPaneL( *aMenuPane,

   936                                                               aResourceId,

   937                                                               ENotepadCmdPrint,

   938                                                               iServiceHandler->InParamListL()

   939                                                             );

   940                         }

   941                         else

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

   943                         {

   944                         aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

   945                         }

   946                     } // KFeatureIdFfEnablePrintingFramework

   947                 else

   948                     {

   949                     aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

   950                     } 

   951                 }

   952             TInt currIndex = iListBox->CurrentItemIndex();

   953             TKeyArrayFix itemKey(0,ECmpTUint);

   954             TInt ignore;

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

   956             if ( memoCount > 0 && 

   957                 ( markCount == 0 || IsNotepad() ) )

   958                 {

   959                 // this must preceed DeleteMenuItem(ENotepadCmdOpen)

   960                 InsertSendMenuItemAfterL( *iSendUi, *aMenuPane, 

   961                     ENotepadCmdOpen );

   962                 }

   963             if ( memoCount == 0 )

   964                 {

   965                 aMenuPane->DeleteMenuItem(ENotepadCmdDelete);

   966                 }

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

   968                 {

   969                 // this must after InsertSendMenuItemAfterL

   970                 aMenuPane->DeleteMenuItem(ENotepadCmdOpen);

   971                 }

   972             }

   973             break;

   974         default:

   975             AknSelectionService::HandleMarkableListDynInitMenuPane(

   976                 aResourceId, aMenuPane, iListBox);

   977             break;

   978         }

   979     }

   980     

   981 // -----------------------------------------------------------------------------

   982 // CNotepadListDialog::DynInitMenuBarL

   983 // from MEikMenuObserver

   984 // -----------------------------------------------------------------------------

   985 //    

   986 void CNotepadListDialog::DynInitMenuBarL(

   987     TInt aResourceId,

   988     CEikMenuBar* aMenuBar )

   989     

   990 {

   991 	

   992 	__ASSERT_DEBUG( aResourceId > 0, 

   993         Panic(ENotepadLibraryPanicNoMenuResource) );

   994     __ASSERT_DEBUG( aMenuBar, Panic(ENotepadLibraryPanicNoMenuResource) );

   995    

   996     if (iMskFlag)

   997     {

   998     	

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

  1000     iMskFlag= EFalse;

  1001     }

  1002     else

  1003     {

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

  1005     }

  1006     

  1007 	

  1008 }

  1009 

  1010 // -----------------------------------------------------------------------------

  1011 // CNotepadListDialog::ProcessCommandL

  1012 // from MEikCommandObserver

  1013 // -----------------------------------------------------------------------------

  1014 //

  1015 void CNotepadListDialog::ProcessCommandL(TInt aCommandId)

  1016     {

  1017     HideMenu();

  1018     switch ( aCommandId )

  1019         {

  1020         case ENotepadCmdOpen: // Open memo

  1021             OnCmdOpenL(iListBox->CurrentItemIndex());

  1022             break;

  1023         case ENotepadCmdAdd:

  1024            OnCmdAddL();

  1025             break;

  1026         case ENotepadCmdDelete:

  1027             OnCmdDeleteL();

  1028             break;

  1029         case ENotepadCmdSend:

  1030         	OnCmdSendL(aCommandId);

  1031         	break;

  1032         default:

  1033             {

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

  1035             if ( aiwServiceCmd == KAiwCmdPrint )

  1036                 {

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

  1038 

  1039                 // Note index

  1040                 TAiwGenericParam noteParam( EGenericParamNoteItem );

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

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

  1043                 inParams.AppendL( noteParam );

  1044 

  1045                 // Application uid

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

  1047                 TAiwGenericParam uidParam( EGenericParamApplication );

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

  1049                 inParams.AppendL( uidParam );

  1050 

  1051                 // Execute service command with given parameters

  1052                 iServiceHandler->ExecuteMenuCmdL( aCommandId,

  1053                                                   inParams,

  1054                                                   iServiceHandler->OutParamListL(),

  1055                                                   0,

  1056                                                   this

  1057                                                 );

  1058                 break;

  1059                 }

  1060 

  1061             AknSelectionService::HandleMarkableListProcessCommandL(

  1062                 aCommandId, iListBox);

  1063             CNotepadDialogBase::ProcessCommandL(aCommandId);

  1064 			TInt appid = EGenericParamContactItem;

  1065 			CAiwGenericParamList* list = AiwSyncParamListLC( appid );

  1066 			iServiceHandler->ExecuteMenuCmdL( aCommandId, *list, iServiceHandler->OutParamListL() );

  1067 			CleanupStack::PopAndDestroy(list);

  1068 			//MSK 			

  1069 			MiddleSoftKeyL();

  1070             break;

  1071             }

  1072         }

  1073     }

  1074 

  1075 // -----------------------------------------------------------------------------

  1076 // CNotepadListDialog::AiwSyncParamListLC

  1077 // -----------------------------------------------------------------------------

  1078 //

  1079 CAiwGenericParamList* CNotepadListDialog::AiwSyncParamListLC(TInt /*aApplicationId*/)

  1080     {

  1081     TAiwVariant variant;

  1082     variant.Set(KNullDesC);

  1083     TAiwGenericParam param(EGenericParamNoteItem, variant);

  1084     CAiwGenericParamList* list = CAiwGenericParamList::NewLC();

  1085     list->AppendL(param);

  1086     return list;

  1087     }

  1088 

  1089 // -----------------------------------------------------------------------------

  1090 // CNotepadListDialog::HandleViewEventL

  1091 // from MCoeViewObserver

  1092 // It seems that observing a view is canceled once this function leave,

  1093 // So we decide to avoid leaving in this function.

  1094 // -----------------------------------------------------------------------------

  1095 //

  1096 void CNotepadListDialog::HandleViewEventL(const TVwsViewEvent& aEvent)

  1097     {

  1098     if ( aEvent.iViewOneId.iAppUid.iUid != aEvent.iViewTwoId.iAppUid.iUid )

  1099         {

  1100         TRAPD(err, DoHandleViewEventL(aEvent); );

  1101         if ( err != KErrNone )

  1102             {

  1103             iCoeEnv->HandleError(err);

  1104             }

  1105         }

  1106     }

  1107 

  1108 // -----------------------------------------------------------------------------

  1109 // CNotepadListDialog::DialogDismissedL

  1110 // From MProgressDialogCallback.

  1111 //

  1112 // MProgressDialogCallback::DialogDismissedL is called from

  1113 // CAknProgressDialog::OkToExitL.

  1114 // This means that if DialogDismissedL LEAVEs, CAknProgressDialog fails to

  1115 // exit.

  1116 // We want to kill our ProgressDialog even though SyncL leaves,

  1117 // so we decide to TRAP SyncL.

  1118 // -----------------------------------------------------------------------------

  1119 //

  1120 void CNotepadListDialog::DialogDismissedL( TInt /*aButtonId*/ )

  1121     {

  1122     iModel->CancelDeletion();

  1123     DrawDeferred();

  1124     }

  1125 

  1126 // -----------------------------------------------------------------------------

  1127 // CNotepadListDialog::PreLayoutDynInitL

  1128 // from CEikDialog

  1129 // -----------------------------------------------------------------------------

  1130 //

  1131 void CNotepadListDialog::PreLayoutDynInitL()

  1132     {

  1133     iListBox = STATIC_CAST(CAknColumnListBox*, Control(ENotepadIdListBox));

  1134     __ASSERT_DEBUG( iListBox, Panic(ENotepadLibraryPanicNullListControl) );