1 /*

     2 * Copyright (c) 2008 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:   Missed event view's container implementation

    15 *

    16 */

    17 

    18 

    19 

    20 // system includes

    21 #include <AknLayoutFont.h>

    22 #include <aknnavide.h>      // CAknNavigationDecorator

    23 #include <aknnavilabel.h>   // CAknNaviLabel

    24 #include <AknsBasicBackgroundControlContext.h>

    25 #include <AknBidiTextUtils.h>

    26 #include <AknsDrawUtils.h>

    27 #include <calrrule.h>

    28 #include <calalarm.h>

    29 #include <calentry.h>

    30 #include <calinstance.h>

    31 #include <eikappui.h>

    32 #include <eikdef.h>

    33 #include <eikedwin.h>

    34 #include <eikenv.h>

    35 #include <eikmenup.h>   // CEikMenuPane

    36 #include <eikmfne.h>

    37 #include <featmgr.h>    // FeatureManager

    38 #include <eikrted.h>    // CEikRichTextEditor

    39 #include <finditemdialog.h>

    40 #include <StringLoader.h>

    41 #include <txtrich.h>    // CRichText

    42 #include <gdi.h>

    43 #include <ItemFinder.h> //Autofinder 

    44 #include <finditemmenu.h>

    45 #include <finditem.hrh>

    46 #include <centralrepository.h>

    47 #include <cenrepnotifyhandler.h>

    48 #include <CommonUiInternalCRKeys.h>

    49 #include <AknUtils.h> 

    50 #include <avkon.hrh>    // EAknCmdHelp

    51 #include <avkon.mbg>

    52 #include <avkon.rsg>

    53 #include <aknlayoutscalable_apps.cdl.h>

    54 #include <csxhelp/cale.hlp.hrh>

    55 #include <calendateutils.h>

    56 #include <calenagendautils.h>

    57 #include <CalenInterimUtils2.h>

    58 #include <calentryview.h>

    59 #include <calcommon.h>

    60 #include <calendar.mbg>

    61 #include <Calendar.rsg>

    62 #include <calencommands.hrh>            // Calendar commands

    63 #include <calencontext.h>

    64 #include <caleninstanceid.h>            // TCalenInstanceId

    65 #include <calenservices.h>

    66 #include <calentoolbar.h>

    67 

    68 // user includes

    69 #include "calenmissedeventcontainer.h"

    70 #include "calennativeview.h"

    71 #include "calendarui_debug.h"

    72 #include "calenicondrawer.h"

    73 #include "calennotedatautil.h"

    74 #include "calenentryutil.h"

    75 #include "CalenUid.h"   // KUidCalendar

    76 #include "calenlocationutil.h"

    77 

    78 // LOCAL CONSTANTS AND MACROS

    79 _LIT( KWesternSummaryMarker, "\x200E" );

    80 _LIT( KArabicSummaryMarker , "\x200F" );

    81 _LIT(KSpace, " ");

    82 _LIT(KYearFormatString,"%F%Y");

    83 

    84 const TInt KDefaultRightMargin=0;

    85 const TInt KScrollViewerUp = 1;

    86 const TInt KScrollViewerDown = -1;

    87 const TInt KMaxDateLength = 32;

    88 

    89 //PANIC CODE

    90 enum TPanicCode

    91     {   

    92     EPanicArrayOfSizeZero=2,

    93     };

    94     

    95 // ----------------------------------------------------------------------------

    96 // CCalenMissedEventContainer::CCalenMissedEventContainer

    97 // C++ constructor.

    98 // ----------------------------------------------------------------------------

    99 //

   100 CCalenMissedEventContainer::CCalenMissedEventContainer(CCalenNativeView* aView,

   101                               MCalenServices& aServices  )

   102     : CCalenContainer( aView, aServices ),

   103     					  iEntry(NULL)

   104     					 

   105     {

   106 	TRACE_ENTRY_POINT;

   107 	TRACE_EXIT_POINT;

   108     }

   109  

   110 // ----------------------------------------------------------------------------

   111 // CCalenMissedEventContainer::~CCalenMissedEventContainer

   112 // Destructor

   113 // ----------------------------------------------------------------------------

   114 //

   115 CCalenMissedEventContainer::~CCalenMissedEventContainer()

   116 	{

   117 	TRACE_ENTRY_POINT;

   118 	

   119 	if(iEntry)

   120 		{

   121 		delete iEntry;

   122 		}

   123 	

   124 	iFetchedEntries.ResetAndDestroy();

   125 	

   126 	delete iParaFormat;	

   127 	delete iSearchBuf;

   128 	delete iEventViewData;

   129 	delete iTextEditor;

   130 	delete iBgContext;

   131     delete iTimeFormat;

   132     delete iDateFormat;

   133     

   134  

   135     delete iFindMenu;

   136     

   137     if( iNotifier )

   138         {

   139         iNotifier->StopListening();

   140         delete iNotifier;        

   141         };

   142         

   143     delete iCenRepSession;	

   144 	TRACE_EXIT_POINT;

   145 	}

   146 

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

   148 // CCalenMissedEventContainer::ConstructImplL

   149 // Third phase constructor.

   150 // This function was called CCalenNativeView::ConstructL().

   151 // (other items were commented in a header).

   152 // ----------------------------------------------------------------------------

   153 //

   154 void CCalenMissedEventContainer::ConstructImplL()

   155 	{

   156 	TRACE_ENTRY_POINT;

   157 	

   158 	iTimeFormat = StringLoader::LoadL( R_QTN_TIME_USUAL_WITH_ZERO, CEikonEnv::Static() );

   159     iDateFormat = StringLoader::LoadL( R_QTN_DATE_USUAL_WITH_ZERO, CEikonEnv::Static() );

   160 	

   161     iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgAreaMain,

   162                                                            Rect(),

   163                                                            ETrue );

   164      

   165    

   166     iFindMenu = CFindItemMenu::NewL( EFindItemMenuPlaceHolder );

   167     iFindMenu->AttachItemFinderMenuL(0);

   168     

   169     iParaFormat = CParaFormat::NewL();

   170 

   171 	

   172 	iTextEditor = new (ELeave) CEikRichTextEditor;

   173     iTextEditor->ConstructL(this, 0, 0, CEikEdwin::EReadOnly | CEikEdwin::EAvkonDisableCursor | 

   174     									CEikEdwin::ENoAutoSelection|CEikEdwin::EAvkonEditor); 

   175     iTextEditor->SetMopParent(this);

   176     iTextEditor->SetRect( Rect() );

   177 	

   178     

   179 	iTextEditor->EnableKineticScrollingL(ETrue);

   180 	

   181 	//Set toolbar visibility to false, bcoz this view is not using the ToolBar

   182 	MCalenToolbar* toolbar = iServices.ToolbarOrNull(); 

   183     if(toolbar)

   184       {

   185       toolbar->SetToolbarVisibilityL(EFalse);  

   186       }

   187 	    

   188    	TRACE_EXIT_POINT;

   189 	}

   190 

   191 // ----------------------------------------------------------------------------

   192 // CCalenMissedEventContainer::UpdateSize

   193 // Do layout changes after calendar settings are

   194 // changed.  No necessary actions for this view.

   195 // ----------------------------------------------------------------------------

   196 //

   197 void CCalenMissedEventContainer::UpdateSize()

   198 	{

   199 	TRACE_ENTRY_POINT;

   200 	

   201 	TRACE_EXIT_POINT;

   202 	}

   203 

   204 // ----------------------------------------------------------------------------

   205 // CCalenMissedEventContainer::CreateIconIndicesL

   206 // Second and final stage of population.

   207 // (other items were commented in a header).

   208 // ----------------------------------------------------------------------------

   209 //

   210 void CCalenMissedEventContainer::CreateIconIndicesL( RArray<MCalenServices::TCalenIcons>& /*aIndexArray*/ )

   211     {

   212     TRACE_ENTRY_POINT;

   213 

   214     TRACE_EXIT_POINT;

   215     }

   216 

   217 // ----------------------------------------------------------------------------

   218 // CCalenMissedEventContainer::CompletePopulationL

   219 // Complete population

   220 // (other items were commented in a header).

   221 // ----------------------------------------------------------------------------

   222 //

   223 void CCalenMissedEventContainer::CompletePopulationL()

   224 	{

   225 	TRACE_ENTRY_POINT;

   226     

   227     iTextEditor->SetFocus(ETrue);

   228 	ActivateL();

   229 	AddToStackAndMakeVisibleL();

   230 	DrawDeferred();

   231 	

   232 	TRACE_EXIT_POINT;

   233 	}

   234 

   235 // ----------------------------------------------------------------------------

   236 // CCalenMissedEventContainer::HandleNaviDecoratorEventL

   237 // ?implementation_description

   238 // (other items were commented in a header).

   239 // ----------------------------------------------------------------------------

   240 //

   241 void CCalenMissedEventContainer::HandleNaviDecoratorEventL( TInt /*aEventID*/ )

   242 	{

   243 	TRACE_ENTRY_POINT;

   244 	

   245 	TRACE_EXIT_POINT;	

   246 	}

   247 

   248 // ----------------------------------------------------------------------------

   249 // CCalenMissedEventContainer::HandleLongTapEventL

   250 // processing of a long tap event

   251 // (other items were commented in a header).

   252 // ----------------------------------------------------------------------------

   253 //

   254 void CCalenMissedEventContainer::HandleLongTapEventL( const TPoint& /*aPenEventLocation*/,

   255                                               const TPoint& /*aPenEventScreenLocation*/ )

   256     {

   257     TRACE_ENTRY_POINT;

   258 

   259     TRACE_EXIT_POINT;

   260     }

   261 

   262 // ----------------------------------------------------------------------------

   263 // CCalenMissedEventContainer::Draw

   264 // (other items were commented in a header).

   265 // ----------------------------------------------------------------------------

   266 //

   267 void CCalenMissedEventContainer::Draw(const TRect& /*aRect*/) const

   268 	{

   269 	TRACE_ENTRY_POINT;

   270 	

   271 	CWindowGc& gc = SystemGc();

   272         

   273     TRect mainPane;

   274     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane );

   275     TRect bgContextRect( TPoint(0, 0), mainPane.Size() );

   276     iBgContext->SetRect( bgContextRect);

   277     iBgContext->SetParentPos(mainPane.iTl);

   278     AknsDrawUtils::Background( AknsUtils::SkinInstance(), iBgContext, this, gc, Rect());

   279 

   280 	

   281 	TRACE_EXIT_POINT;

   282 	}

   283 

   284 // ----------------------------------------------------------------------------

   285 // CCalenMissedEventContainer::Sizechanged

   286 // Child control was resized.

   287 // (other items were commented in a header)

   288 // ----------------------------------------------------------------------------

   289 //

   290 void CCalenMissedEventContainer::SizeChanged()

   291     {

   292     TRACE_ENTRY_POINT;

   293 

   294      if (iTextEditor)

   295         {

   296      	TRAPD(error,iTextEditor->HandleTextChangedL() );

   297 		if(error!=KErrNone)

   298 	    	{

   299 	    	// Do nothing to avoid warning

   300 	    	}

   301    	    }

   302     

   303     TRACE_EXIT_POINT;    

   304     }

   305     

   306 // ----------------------------------------------------------------------------

   307 // CCalenMissedEventContainer::CountComponentControls

   308 // Return child control count.

   309 // (other items were commented in a header).

   310 // ----------------------------------------------------------------------------

   311 //

   312 TInt CCalenMissedEventContainer::CountComponentControls() const

   313     {

   314     TRACE_ENTRY_POINT;

   315     TRACE_EXIT_POINT;

   316     return 1;

   317     }

   318 

   319 // ----------------------------------------------------------------------------

   320 // CCalenMissedEventContainer::ComponentControl

   321 // Return child control pointer.

   322 // (other items were commented in a header).

   323 // ----------------------------------------------------------------------------

   324 //

   325 CCoeControl* CCalenMissedEventContainer::ComponentControl(TInt /*aIndex*/) const     // Child control index

   326     {

   327     TRACE_ENTRY_POINT;

   328     TRACE_EXIT_POINT;

   329     return iTextEditor;

   330     }

   331 

   332 // ----------------------------------------------------------------------------

   333 // CCalenMissedEventContainer::OfferKeyEventL

   334 // Process key event.

   335 // (other items were commented in a header).

   336 // ----------------------------------------------------------------------------

   337 //

   338 TKeyResponse CCalenMissedEventContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

   339     {

   340     TRACE_ENTRY_POINT;

   341 

   342     TKeyResponse keyResponse(EKeyWasNotConsumed);

   343 

   344     if (aType == EEventKey)

   345         {

   346         switch (aKeyEvent.iCode)

   347             {

   348             case EKeyUpArrow:

   349                 {

   350                

   351                 // Scroll the text view up by one line

   352                 iTextEditor->MakeVisible(EFalse);

   353                 TInt scrollLines = KScrollViewerUp;

   354                 iTextEditor->TextView()->ScrollDisplayLinesL(scrollLines);

   355                 iTextEditor->UpdateScrollBarsL();

   356                 iTextEditor->MakeVisible(ETrue);

   357                 //Set focus immediately for highlight of auto find text 

   358                 iTextEditor->SetFocus(ETrue);

   359                 keyResponse = EKeyWasConsumed;

   360                 }

   361                 break;

   362 

   363             case EKeyDownArrow:

   364                 {

   365                

   366                 // Scroll the text view down by one line

   367                 iTextEditor->MakeVisible(EFalse);

   368                 TInt scrollLines = KScrollViewerDown;

   369                 iTextEditor->TextView()->ScrollDisplayLinesL(scrollLines);

   370                 iTextEditor->UpdateScrollBarsL();

   371                 iTextEditor->MakeVisible(ETrue);

   372                 //Set focus immediately for highlight of auto find text

   373                 iTextEditor->SetFocus(ETrue);

   374                 keyResponse = EKeyWasConsumed;

   375                 }

   376                 break;

   377                 

   378             case EKeyOK:

   379             	{            	

   380               	iView->HandleCommandL(ECalenCmdPromptThenEdit);

   381                 keyResponse = EKeyWasConsumed;

   382             	}

   383                 break;

   384             case EKeyEscape:

   385             	{

   386             	// Calendar relaunched from cmd line - close viewer

   387                 iView->HandleCommandL(EAknSoftkeyBack);

   388                 keyResponse = EKeyWasConsumed;

   389             	}

   390                 break;

   391             case EKeyPhoneSend:

   392              	{

   393                 if(CCalenLocationUtil::IsMapProviderAvailableL())	

   394 					{

   395 					iServices.IssueCommandL(ECalenGetLocationAndSave);

   396     				keyResponse = EKeyWasConsumed;		

   397 					}

   398                 break;

   399               }

   400             case EKeyApplication0:

   401             	{

   402             	TPtrC location = iEntry->LocationL();

   403 				if(location.Length() || iEntry->GeoValueL())

   404 					{

   405 					if(CCalenLocationUtil::IsMapProviderAvailableL())	

   406     					{

   407     					iServices.IssueCommandL(ECalenShowLocation);

   408         				keyResponse = EKeyWasConsumed;		

   409     					}

   410 					}	

   411              	}

   412                 break;

   413             case EKeyBackspace:  /* fall through... */

   414             case EKeyDelete:

   415             	{            

   416              	iView->HandleCommandL( ECalenDeleteCurrentEntry );            	

   417             	}

   418                 break;

   419             default:

   420                 break;

   421             }

   422         }

   423 

   424     // Swallow all other keyevents to prevent the active container processing them.

   425     keyResponse = EKeyWasConsumed;

   426 

   427     TRACE_EXIT_POINT;

   428     return keyResponse;

   429 

   430  

   431     }

   432 

   433 

   434 // ----------------------------------------------------------------------------

   435 // CCalenMissedEventContainer::HandlePointerEventL

   436 // Process pointer event.

   437 // (other items were commented in a header).

   438 // ----------------------------------------------------------------------------

   439 //

   440 void CCalenMissedEventContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent)

   441     {

   442     TRACE_ENTRY_POINT;

   443     

   444     if(!AknLayoutUtils::PenEnabled())

   445 	 {

   446 	 	return;

   447 	 }

   448     CCalenContainer::HandlePointerEventL( aPointerEvent );

   449     if(iTextEditor->Rect().Contains(aPointerEvent.iPosition))

   450     	{

   451     	switch(aPointerEvent.iType)

   452     		{

   453     		case TPointerEvent::EButton1Down:

   454     			{

   455     			iTextEditor->SetFocus(ETrue);

   456     			break;

   457     			}

   458     		case TPointerEvent::EDrag:

   459     			{

   460     			iTextEditor->SetFocus(ETrue);

   461     			break;

   462     			}

   463     		case TPointerEvent::EButton1Up:

   464     			{

   465     			iTextEditor->SetFocus(ETrue);

   466     			TInt curPos = iTextEditor->CursorPos();	

   467 		        TRect rect = iTextEditor->Rect();  

   468     			break;	

   469     			}

   470     		default:

   471     			{

   472     			break;	

   473     			}	

   474     		}

   475        	}    

   476        	

   477     TRACE_EXIT_POINT;

   478     }

   479     

   480 // ----------------------------------------------------------------------------

   481 // CCalenMissedEventContainer::GetHelpContext

   482 // Get help context.

   483 // (other items were commented in a header).

   484 // ----------------------------------------------------------------------------

   485 //

   486 void CCalenMissedEventContainer::GetHelpContext(TCoeHelpContext& aContext) const

   487     {

   488     TRACE_ENTRY_POINT;

   489     

   490     aContext.iMajor = KUidCalendar;

   491     aContext.iContext = KCALE_HLP_NOTE_VIEWER; // need to change	

   492 	

   493     TRACE_EXIT_POINT;

   494     }

   495 

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

   497 // CCalenMissedEventContainer::HandleResourceChange

   498 // Handles a resource relative event

   499 // (other items were commented in a header).

   500 // ----------------------------------------------------------------------------

   501 //

   502 void CCalenMissedEventContainer::HandleResourceChange(TInt aType)

   503     {

   504     TRACE_ENTRY_POINT; 

   505 

   506     CCalenContainer::HandleResourceChange( aType );

   507     

   508     if(( aType == KUidValueCoeColorSchemeChangeEvent ) ||

   509         ( aType == KUidValueCoeZoomChangeEvent ) ||

   510         ( aType == KUidValueCoeFontChangeEvent ))

   511         {

   512         CEikAppUi* appUi = static_cast<CEikAppUi*>( ControlEnv()->AppUi() );

   513         SetRect( appUi->ClientRect() );

   514         /*TRect mainPane;

   515         AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane );

   516         SetRect( mainPane );*/

   517         }

   518     

   519     if(aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)

   520         {

   521         SizeChanged();

   522 

   523         SetupFontL();

   524         // refresh

   525         TRAPD(err,iView->BeginRepopulationL());

   526         if(err!=KErrNone)

   527             {

   528             // do avoid warning

   529             } 

   530         }

   531     

   532     CCoeControl::HandleResourceChange( aType );

   533     

   534     TRACE_EXIT_POINT;

   535     }

   536 

   537 // ----------------------------------------------------------------------------

   538 // CCalenMissedEventContainer::BuildTextEditorL

   539 // Build text editor

   540 // (other items were commented in a header).

   541 // ----------------------------------------------------------------------------

   542 //

   543 void CCalenMissedEventContainer::BuildTextEditorL()

   544 	{

   545 	TRACE_ENTRY_POINT; 

   546         

   547     iTextEditor->SetFocus(EFalse);    

   548     iTextEditor->SetRect( Rect() );

   549     iTextEditor->RichText()->Reset();

   550     

   551     // Create the scroll bars.

   552     iTextEditor->CreateScrollBarFrameL();

   553     iTextEditor->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   554     iTextEditor->SetAknEditorFlags(EAknEditorFlagEnableScrollBars);

   555     iTextEditor->ScrollBarFrame()->VerticalScrollBar()->SetMopParent(this);

   556     

   557     iTextEditor->ScrollBarFrame()->SetScrollBarFrameObserver(this);

   558     

   559     TEikScrollBarModel h,v;

   560     TEikScrollBarFrameLayout lay;

   561     CEikAppUi* appUi = static_cast<CEikAppUi*>( ControlEnv()->AppUi() );

   562     TRect rec = appUi->ClientRect();

   563  //   ASSERT( iTextEditor->ScrollBarFrame()->TileL( &h, &v, rec, rec, lay) );

   564     

   565     SetLayoutFromLookAndFeel();

   566     

   567     SetupFontL();

   568     

   569     TRACE_EXIT_POINT;

   570 	}

   571 

   572 // ----------------------------------------------------------------------------

   573 // CCalenMissedEventContainer::SetIconsL

   574 // Set the icons

   575 // (other items were commented in a header).

   576 // ----------------------------------------------------------------------------

   577 //

   578 void CCalenMissedEventContainer::SetIconsL()

   579 	{

   580 	// Create and populate the icon drawer.  We need to do this first to prevent a long

   581     // summary text being drawn over the icons

   582     CCalenIconDrawer* iconDrawer = CCalenIconDrawer::NewL( iServices );

   583     CleanupStack::PushL(iconDrawer);

   584     PopulateIconDrawerL(*iconDrawer);

   585 

   586     // Get rid of the last paragraph delimiter so we can't scroll past the bottom of the text.

   587     iTextEditor->RichText()->DeleteL( iTextEditor->RichText()->DocumentLength()-1, 1 );

   588 

   589     // Create a TPictureHeader to insert our icons into the viewer

   590     TPictureHeader header;

   591     header.iPicture = TSwizzle<CPicture>(iconDrawer);

   592 

   593     // Insert the icon drawer into the Rich Text Editor.  This takes

   594     // ownership of the icon drawer.

   595     // Insert at index 0 in the document to cause the icons to be drawn when

   596     // the first line is visible.  The icons will not be drawn at position 0,

   597     // but this position must be on the screen for the icons to be drawn.

   598     iTextEditor->RichText()->InsertL( 0, header );

   599 

   600     // Ownership of icon drawer transferred to rich text editor

   601     CleanupStack::Pop(iconDrawer);

   602 

   603     // Tell the text editor that it has been updated.  This will cause

   604     // a redraw.

   605     iTextEditor->HandleTextChangedL();

   606 	

   607 	}

   608 

   609 // ----------------------------------------------------------------------------

   610 // CCalenMissedEventContainer::RequestInstanceViewL

   611 // Request for instance view

   612 // (other items were commented in a header).

   613 // ----------------------------------------------------------------------------

   614 //

   615 void CCalenMissedEventContainer::RequestInstanceViewL()

   616 	{

   617 	TRACE_ENTRY_POINT; 

   618 

   619     MCalenContext& context = iServices.Context();

   620     TCalLocalUid instanceId = context.InstanceId().iEntryLocalUid;

   621 	

   622 	if(iEntry)

   623 		{

   624 		delete iEntry;

   625 		iEntry = NULL;

   626 		}

   627 	

   628 	iEntry = iServices.EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);

   629 	

   630 	TCalTime instanceDateTime;

   631 	instanceDateTime.SetTimeLocalL( context.InstanceId().iInstanceTime );

   632     

   633     if(iEventViewData)

   634     	{

   635     	delete iEventViewData;

   636     	iEventViewData = NULL;

   637     	}

   638     iEventViewData = CCalenEntryUtil::NewL( *iEntry, instanceDateTime );

   639     

   640     TRACE_EXIT_POINT;

   641 	}

   642 

   643 // ----------------------------------------------------------------------------

   644 // CCalenMissedEventContainer::AddFieldsL

   645 // Add the data fields

   646 // (other items were commented in a header).

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

   648 //

   649 void CCalenMissedEventContainer::AddFieldsL()

   650 	{

   651 	TRACE_ENTRY_POINT;

   652 	

   653 	// add subject field

   654 	AddSubjectFieldL();	

   655 	

   656 	switch ( iEntry->EntryTypeL() )

   657         {

   658         case CCalEntry::EReminder:

   659         case CCalEntry::EAppt:

   660         	{

   661         	// start time

   662 		    AddTimeFieldL();

   663 

   664 		    // location

   665 		    AddLocationFieldL();

   666 

   667 		    // extra empty line between primary and secondary information

   668 		    AddEmptyLineL();

   669 

   670 		    // alarm

   671 		    AddAlarmDateTimeFieldL();

   672 

   673 		    // We want to show the repeat fields for repeating parent entries or 

   674 		    // child entries.  If the entry is a child then the repeat information from the

   675 		    // parent will be shown

   676 		    //if ((iEventViewData->IsRepeating()) || (Handler().Edited()->Entry().RecurrenceIdL().TimeUtcL() != Time::NullTTime()))

   677 		    if ((iEventViewData->IsRepeating()) || (iEntry->RecurrenceIdL().TimeUtcL() != Time::NullTTime()))

   678 		        {

   679 		        AddRepeatFieldL();

   680 		        }

   681 		    iTitleTextId = R_CALEN_EVENT_VIEW_MEETING_TITLE;    

   682 		   	}

   683             break;

   684 

   685         case CCalEntry::EAnniv:

   686             {

   687             // date field

   688             AddDateFieldL(iEventViewData->StartDateTime());

   689     		

   690     		// Add the time

   691     		//AddTimeFieldL();

   692 

   693     		// extra empty line between primary and secondary information

   694     		AddEmptyLineL();

   695 

   696     		// alarm

   697     		AddAlarmDateTimeFieldL();

   698 

   699     		// Add the 'since' field.

   700     		AddSinceFieldL();

   701 

   702 		    iTitleTextId = R_CALEN_EVENT_VIEW_ANNIV_TITLE;      		

   703 	        }

   704             break;

   705  

   706         case CCalEntry::EEvent:

   707  			{

   708 		 	// If the start time is on the same day as the end time, just show the date.

   709 			// Otherwise, show "start date - end date".

   710 			TTime startTime = iEventViewData->StartDateTime();

   711 			TTime endTime = iEventViewData->EndDateTime();

   712 

   713 			if( CalenDateUtils::OnSameDay(startTime, endTime) )

   714 				{

   715 				AddDateFieldL(startTime );

   716 				}

   717 			else

   718 				{

   719 				AddDateDateFieldL(startTime, endTime);

   720 				}

   721 

   722 		    // extra empty line between primary and secondary information

   723 		    AddEmptyLineL();

   724 

   725 		    // alarm    

   726 		    AddAlarmDateTimeFieldL();

   727 		    

   728 		    // Currently it's not possible to create a repeating day note in the UI.

   729 		    // However, it is possible to import one from an iCalendar file or create

   730 		    // one in code. Therefore the repeat properties of day notes are shown

   731 		    // if they exist. If the entry is modified (in the editor), the repeat

   732 		    // properties will be lost.

   733 		    if(iEventViewData->IsRepeating())

   734 		        {

   735 		        AddRepeatFieldL();

   736 		        }

   737 		        

   738 		

   739 		    iTitleTextId = R_CALEN_EVENT_VIEW_ALLDAY_TITLE;

   740 		    

   741  			}

   742             break;

   743 

   744         case CCalEntry::ETodo:

   745             {

   746 		    // extra empty line between primary and secondary information

   747 		    AddEmptyLineL();

   748 

   749 			// Due date

   750 			TTime dueDate = iEventViewData->EventDateTime();

   751 		    AddDateFieldL(R_QTN_CALE_EVENT_VIEW_DUE_DATE, dueDate);

   752 

   753 		    // Alarm is only shown if the todo is not complete.

   754 		    //if (Handler().Entry().StatusL() != CCalEntry::ETodoCompleted)

   755 			if (iEntry->StatusL() != CCalEntry::ETodoCompleted)

   756 		        {

   757 		        AddAlarmDateTimeFieldL();

   758 		        }

   759 

   760 		    // Show completion date if complete

   761 		    else

   762 		        {

   763 		        AddDateFieldL(R_QTN_CALE_EVENT_VIEW_COMPLETED, iEntry->CompletedTimeL().TimeLocalL());

   764 		        }

   765 

   766 		    // Priority

   767 		    AddPriorityFieldL();

   768 		    

   769 		    // Repeat rules.  Supporting repeating todos sounds like asking for trouble to me.

   770 		    if (iEventViewData->IsRepeating())

   771 		        {

   772 		        AddRepeatFieldL();

   773 		        }

   774 		        

   775 		    iTitleTextId = R_CALEN_EVENT_VIEW_TODO_TITLE;  			

   776             }

   777             break;

   778 

   779         default:

   780             __ASSERT_DEBUG(EFalse, User::Invariant());

   781             break;

   782         }

   783 

   784 	// Add Description

   785     AddDescriptionFieldL();

   786 	

   787 	SetIconsL();

   788 	TRACE_EXIT_POINT;

   789 	}

   790 

   791 // ----------------------------------------------------------------------------

   792 // CCalenMissedEventContainer::SetLayoutFromLookAndFeel

   793 // Set the layout data

   794 // (other items were commented in a header).

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

   796 //

   797 void CCalenMissedEventContainer::SetLayoutFromLookAndFeel()

   798 	{

   799     TRACE_ENTRY_POINT;

   800 

   801     iParaFormat->Reset();

   802     iParaFormatMask.ClearAll();

   803     iCharFormatMask.ClearAll();

   804 

   805     iParaFormatMask.SetAttrib(EAttLeftMargin);

   806     iParaFormatMask.SetAttrib(EAttRightMargin);

   807 

   808     // Get the main pane

   809     TSize main_pane_size;

   810     AknLayoutUtils::LayoutMetricsSize (AknLayoutUtils::EMainPane, main_pane_size);

   811     TRect main_pane(main_pane_size);

   812 

   813     // Get main_cale_event_viewer_pane with main_pane as parent

   814     TAknLayoutRect main_cale_event_viewer_pane;

   815     main_cale_event_viewer_pane.LayoutRect(main_pane, AknLayoutScalable_Apps::main_cale_event_viewer_pane().LayoutLine() );

   816 

   817     // Get listscroll_cale_event_viewer_pane with main_cale_event_viewer_pane as parent

   818     TAknLayoutRect listscroll_cale_event_viewer_pane;

   819     listscroll_cale_event_viewer_pane.LayoutRect(main_cale_event_viewer_pane.Rect(), AknLayoutScalable_Apps::listscroll_cale_event_viewer_pane().LayoutLine() );

   820 

   821     // Get list_cale_ev2_pane with listscroll_cale_event_viewer_pane as parent

   822     TAknLayoutRect list_cale_ev2_pane;

   823     list_cale_ev2_pane.LayoutRect(listscroll_cale_event_viewer_pane.Rect(), AknLayoutScalable_Apps::list_cale_ev2_pane().LayoutLine() );

   824     iTextEditor->SetRect(list_cale_ev2_pane.Rect());

   825 

   826     //TAknLayoutRect scroll_pane_cp023;

   827     //scroll_pane_cp023.LayoutRect(listscroll_cale_event_viewer_pane.Rect(), AknLayoutScalable_Apps::scroll_pane_cp023().LayoutLine() );

   828     //iTextEditor->ScrollBarFrame()->VerticalScrollBar()->SetRect( scroll_pane_cp023.Rect() );

   829     //layoutVariant = lay.LayoutVariantIndex(2);

   830     AknLayoutUtils::LayoutVerticalScrollBar( iTextEditor->ScrollBarFrame(),

   831                                              listscroll_cale_event_viewer_pane.Rect(),

   832                                              AknLayoutScalable_Apps::scroll_pane_cp023().LayoutLine() );

   833 

   834     // Get field_cale_ev2_pane with list_cale_ev2_pane as parent

   835     TAknLayoutRect field_cale_ev2_pane;

   836     field_cale_ev2_pane.LayoutRect(list_cale_ev2_pane.Rect(), AknLayoutScalable_Apps::field_cale_ev2_pane(0).LayoutLine() );

   837 

   838     // Get field_cale_ev2_pane_t1

   839     TAknTextLineLayout field_cale_ev2_pane_t1 = AknLayoutScalable_Apps::field_cale_ev2_pane_t1(0).LayoutLine();

   840 

   841     // Get heading layout properties from field_cale_ev2_pane_t1 with list_cale_ev2_pane as parent

   842     TAknLayoutText headingTextLayout;

   843     headingTextLayout.LayoutText(list_cale_ev2_pane.Rect(), field_cale_ev2_pane_t1);

   844 

   845     // Set heading indenting and font

   846     if (!AknLayoutUtils::LayoutMirrored())

   847         {

   848         // Normal L-R layout.

   849         // Heading indent is heading text layout rect left x pos -

   850         // text editor rect left xpos.  The heading text layout rect gives us an absolute

   851         // screen position, but the value that we need should be relative to

   852         // the text editor itself

   853         TInt headingIndentPixels =  headingTextLayout.TextRect().iTl.iX -

   854                                     list_cale_ev2_pane.Rect().iTl.iX;

   855         iHeadingIndent    = PixelsToTwips(headingIndentPixels);

   856         }

   857     else

   858         {

   859         // Mirrored, R-L layout.

   860         // Heading indent is the text editor rect right x pos -

   861         // the heading text layout rect right x pos

   862         TInt headingIndentPixels =  list_cale_ev2_pane.Rect().iBr.iX -

   863                                     headingTextLayout.TextRect().iBr.iX;

   864         iHeadingIndent    = PixelsToTwips(headingIndentPixels);

   865         }

   866 

   867     iHeadingFontSpec  = headingTextLayout.Font()->FontSpecInTwips();

   868     iHeadingFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   869     iEmptyLineHeight  = PixelsToTwips(headingTextLayout.TextRect().Height() / 2);

   870 

   871     // Get field_cale_ev2_pane_t2

   872     TAknTextLineLayout field_cale_ev2_pane_t2 = AknLayoutScalable_Apps::field_cale_ev2_pane_t2(0).LayoutLine();

   873 

   874     // Get body layout properties from field_cale_ev2_pane_t2 // with field_ev_content_pane as parent

   875     TAknLayoutText bodyTextLayout;

   876     bodyTextLayout.LayoutText(list_cale_ev2_pane.Rect(), field_cale_ev2_pane_t2);

   877     iMaxWidth = bodyTextLayout.TextRect().Width();

   878 

   879     // Set body indenting and font

   880     if (!AknLayoutUtils::LayoutMirrored())

   881         {

   882         // Normal L-R layout.

   883         // Body text indent is body text layout rect left x pos -

   884         // text editor rect left xpos.  The heading text layout rect gives us an absolute

   885         // screen position, but the value that we need should be relative to

   886         // the text editor itself

   887         TInt bodyIndentPixels = bodyTextLayout.TextRect().iTl.iX -

   888                                 list_cale_ev2_pane.Rect().iTl.iX;

   889         iBodyIndent    = PixelsToTwips(bodyIndentPixels);

   890         }

   891     else

   892         {

   893         // Mirrored, R-L layout.

   894         // Body indent is the text editor rect right x pos -

   895         // the body text layout rect right x pos

   896         TInt bodyIndentPixels = list_cale_ev2_pane.Rect().iBr.iX -

   897                                 bodyTextLayout.TextRect().iBr.iX;

   898         iBodyIndent = PixelsToTwips(bodyIndentPixels);

   899         }

   900 

   901     iBodyFontSpec = bodyTextLayout.Font()->FontSpecInTwips();

   902     iBodyFont = bodyTextLayout.Font(); // Used for TryToFitL	

   903 	

   904 	TRACE_EXIT_POINT;

   905 	}		

   906 

   907 // ----------------------------------------------------------------------------

   908 // CCalenMissedEventContainer::SetupFontL

   909 // Set the font colour, and set default para/char format layers to the

   910 // rich text editor.

   911 // (other items were commented in a header).

   912 // ----------------------------------------------------------------------------

   913 //

   914 void CCalenMissedEventContainer::SetupFontL()	

   915 	{

   916     TRACE_ENTRY_POINT;

   917 

   918     // Set desired character formatting attributes. Gets sensible text colour based on theme.

   919     TRgb textColourFromSkin(255,0,0);					 // If you see bright red text, the skins api is broken!

   920     MAknsSkinInstance* skin = AknsUtils::SkinInstance(); // Does not transfer ownership.

   921     AknsUtils::GetCachedColor(skin, textColourFromSkin, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6);

   922 

   923     TCharFormat charFormat;

   924     TCharFormatMask charFormatMask;

   925     // Set the text colour we found.

   926     charFormat.iFontPresentation.iTextColor = TLogicalRgb(textColourFromSkin);

   927     charFormatMask.SetAttrib(EAttColor);

   928 

   929     // Set up our paragraph formatting attributes.

   930     CParaFormat* paraFormat = CParaFormat::NewLC();

   931     TParaFormatMask paraFormatMask;

   932 

   933     // Set up the default font so it's the same as the body text used.

   934     // This means we can do without setting the para/char format layers

   935     // when adding body text.

   936     paraFormat->iLeftMarginInTwips = iBodyIndent;

   937     paraFormatMask.SetAttrib(EAttLeftMargin);

   938     paraFormatMask.SetAttrib(EAttRightMargin);

   939 

   940     charFormat.iFontSpec = iBodyFontSpec;

   941     charFormatMask.SetAttrib(EAttFontHeight);

   942     charFormatMask.SetAttrib(EAttFontTypeface);

   943     charFormatMask.SetAttrib(EAttFontStrokeWeight);

   944 

   945     // Create some format layers based on the attributes we specified above.

   946     // The underlying Edwin will take ownership of the format objects created below, so don't need to delete.

   947     CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL(paraFormat, paraFormatMask);

   948     CleanupStack::PushL(paraFormatLayer);

   949     CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL(charFormat, charFormatMask);

   950     CleanupStack::Pop(paraFormatLayer);

   951 

   952     // Set the format layers.

   953     iTextEditor->SetParaFormatLayer(paraFormatLayer);

   954     iTextEditor->SetCharFormatLayer(charFormatLayer);

   955 

   956     // And get rid of paraFormat. All other allocations are owned by the CEikRichTextEditor.

   957     CleanupStack::PopAndDestroy(paraFormat);	

   958 

   959 	TRACE_EXIT_POINT;

   960 	}		

   961 

   962 // -----------------------------------------------------------------------------

   963 // CCalenViewerBase::PopulateIconDrawerL

   964 // Ask IconDrawer to prepare icons that are going to be drawn

   965 // (other items were commented in a header).

   966 // -----------------------------------------------------------------------------

   967 //

   968 void CCalenMissedEventContainer::PopulateIconDrawerL(CCalenIconDrawer& aIconDrawer)

   969     {

   970     TRACE_ENTRY_POINT;

   971 

   972     // Alarm icon?

   973     if( iEventViewData->IsAlarmActivated() )

   974         {

   975         // For todos, only add the alarm icon if it's not completed.

   976         if ( iEventViewData->EntryType() == CCalEntry::ETodo )

   977             {

   978           //  if(iEditedCalEntry.StatusL() != CCalEntry::ETodoCompleted)

   979           	if(iEntry->StatusL() != CCalEntry::ETodoCompleted)	

   980                 {

   981                 aIconDrawer.AddIconL( MCalenServices::ECalenAlarmIcon );

   982                 }

   983             }

   984         else

   985             {

   986             aIconDrawer.AddIconL( MCalenServices::ECalenAlarmIcon );

   987             }

   988         }

   989 

   990     // Repeat / exception icon?

   991     if (iEventViewData->IsRepeating())

   992         {

   993         aIconDrawer.AddIconL( MCalenServices::ECalenRepeatIcon );

   994         }

   995     else

   996         {

   997         if (iEntry->RecurrenceIdL().TimeUtcL() != Time::NullTTime())

   998             {

   999             aIconDrawer.AddIconL( MCalenServices::ECalenRepeatExceptionIcon );

  1000             }

  1001         }

  1002 

  1003     // Todo priority icon?

  1004     if (iEventViewData->EntryType() == CCalEntry::ETodo)

  1005         {

  1006         CCalenEntryUtil::TTodoPriority priority = iEventViewData->Priority();

  1007         if (priority == CCalenEntryUtil::ETodoPriorityHigh)

  1008             {

  1009             aIconDrawer.AddIconL( MCalenServices::ECalenNotePriorityHigh );

  1010             }

  1011         else if (priority == CCalenEntryUtil::ETodoPriorityLow)

  1012             {

  1013             aIconDrawer.AddIconL( MCalenServices::ECalenNotePriorityLow );

  1014             }

  1015         else

  1016             {

  1017             // nothing

  1018             }

  1019         }

  1020      // Map icon if event has geo coordinates

  1021      CCalGeoValue* geovalue = iEntry->GeoValueL();

  1022     if(geovalue)

  1023 	     {

  1024 	     aIconDrawer.AddIconL( MCalenServices::ECalenMapIcon );

  1025 	     delete geovalue;

  1026 	     }

  1027     // Set the icon sizes

  1028     aIconDrawer.SetIconSizesFromLayout();

  1029 

  1030     // Get the icon drawer width

  1031     iIconDrawerWidthInPixels = aIconDrawer.WidthInPixels();

  1032 

  1033     TRACE_EXIT_POINT;

  1034     }

  1035 

  1036 // -----------------------------------------------------------------------------

  1037 // CCalenMissedEventContainer::SetFormatAndAddHeadingL

  1038 // 

  1039 // -----------------------------------------------------------------------------

  1040 //

  1041 void CCalenMissedEventContainer::SetFormatAndAddHeadingL(const TDesC& aHeading)

  1042     {

  1043 	TRACE_ENTRY_POINT;

  1044 

  1045     iCharFormatMask.ClearAll();

  1046     iParaFormat->iLeftMarginInTwips = iHeadingIndent;

  1047     iCharFormat.iFontSpec = iHeadingFontSpec;

  1048     iCharFormatMask.SetAttrib( EAttFontHeight );

  1049     iCharFormatMask.SetAttrib( EAttFontTypeface );

  1050     iCharFormatMask.SetAttrib( EAttFontStrokeWeight );

  1051     AddFormattedTextL( aHeading );

  1052 	

  1053 	TRACE_EXIT_POINT;

  1054     }

  1055 

  1056 // -----------------------------------------------------------------------------

  1057 // CCalenMissedEventContainer::SetFormatAndAddBodyL

  1058 // 

  1059 // -----------------------------------------------------------------------------

  1060 //

  1061 void CCalenMissedEventContainer::SetFormatAndAddBodyL(const TDesC& aBody)

  1062     {

  1063     TRACE_ENTRY_POINT;

  1064 

  1065     iCharFormatMask.ClearAll();

  1066     iParaFormat->iLeftMarginInTwips = iBodyIndent;

  1067     iCharFormat.iFontSpec = iBodyFontSpec;

  1068     iCharFormatMask.SetAttrib( EAttFontHeight );

  1069     iCharFormatMask.SetAttrib( EAttFontTypeface );

  1070     iCharFormatMask.SetAttrib( EAttFontStrokeWeight );

  1071     AddFormattedTextL( aBody );

  1072 

  1073     TRACE_EXIT_POINT;

  1074     }

  1075 

  1076 // -----------------------------------------------------------------------------

  1077 // CCalenMissedEventContainer::AddEmptyLineL

  1078 // 

  1079 // -----------------------------------------------------------------------------

  1080 //

  1081 void CCalenMissedEventContainer::AddEmptyLineL()

  1082     {

  1083    	TRACE_ENTRY_POINT; 

  1084 

  1085     CParaFormat* paraFormat = CParaFormat::NewLC();

  1086     TParaFormatMask paraFormatMask;

  1087     paraFormat->iLineSpacingControl = CParaFormat::ELineSpacingExactlyInTwips;

  1088     paraFormatMask.SetAttrib(EAttLineSpacingControl);

  1089     paraFormat->iLineSpacingInTwips = iEmptyLineHeight;

  1090     paraFormatMask.SetAttrib(EAttLineSpacing);

  1091     paraFormatMask.SetAttrib(EAttFontHighlightColor);

  1092 

  1093     CRichText* richText = iTextEditor->RichText();

  1094     TInt startPos = richText->DocumentLength();

  1095     richText->InsertL(richText->DocumentLength(), CEditableText::EParagraphDelimiter);

  1096     TInt endPos = richText->DocumentLength();

  1097 

  1098     richText->ApplyParaFormatL(paraFormat, paraFormatMask, startPos, endPos - startPos);

  1099 

  1100     CleanupStack::PopAndDestroy(paraFormat);

  1101 

  1102 	TRACE_EXIT_POINT;    

  1103     }

  1104 

  1105 // -----------------------------------------------------------------------------

  1106 // CCalenMissedEventContainer::AddFormattedTextL

  1107 // Add a string to the view.

  1108 // (other items were commented in a header).

  1109 // -----------------------------------------------------------------------------

  1110 //

  1111 void CCalenMissedEventContainer::AddFormattedTextL(const TDesC& aText)

  1112     {

  1113     TRACE_ENTRY_POINT;

  1114 

  1115     CRichText* richText = iTextEditor->RichText();

  1116     TInt startPos = richText->DocumentLength();

  1117     HBufC* text = HBufC::NewLC( aText.Length() + 10);

  1118     TPtr target = text->Des();

  1119     if(AknLayoutUtils::LayoutMirrored())

  1120     	{

  1121         target.Append(KArabicSummaryMarker);    

  1122     	}

  1123     else

  1124     	{

  1125         target.Append(KWesternSummaryMarker);

  1126     	}

  1127     target.Append(aText);

  1128     

  1129     richText->InsertL(startPos, target);

  1130     richText->InsertL(richText->DocumentLength(), CEditableText::EParagraphDelimiter);

  1131     TInt endPos = richText->DocumentLength();

  1132 

  1133     richText->ApplyCharFormatL(iCharFormat, iCharFormatMask, startPos, endPos - startPos);