1 /*

     2 * Copyright (c) 2007 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:  For Day view container of calendar application.

    15  *                The class derived from CCalenContainer

    16  *

    17 */

    18 

    19 

    20 //debug

    21 #include "calendarui_debug.h"

    22 

    23 // INCLUDE FILES

    24 #include "calendaycontainer.h"

    25 #include "calencontainerlayoutmanager.h"

    26 #include "calencontroller.h"

    27 

    28 #include <calenconstants.h>

    29 #include <calendateutils.h>

    30 #include "calendaylistboxmodel.h"

    31 #include "calendaylistboxview.h"

    32 #include "calendaylistbox.h"

    33 #include "calendayview.h"

    34 #include "CalenUid.h"

    35 #include <calenagendautils.h>

    36 #include <calenservices.h>

    37 #include "calenlocationutil.h"

    38 

    39 #include "calendar.hrh"

    40 #include <Calendar.rsg>

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

    42 

    43 #include <AknsDrawUtils.h>

    44 #include <AknsFrameBackgroundControlContext.h>

    45 #include <AknUtils.h>

    46 #include <AknIconArray.h>

    47 #include <eikfrlbd.h>

    48 #include <eiklabel.h>

    49 #include <eikmenub.h>

    50 #include <StringLoader.h>

    51 #include <calenviewutils.h>

    52 #include <aknlayoutscalable_apps.cdl.h>

    53 

    54 #include <calinstance.h>

    55 #include <calentry.h>

    56 #include <calinstanceview.h>

    57 #include <caltime.h>

    58 

    59 #include <AknDef.h>

    60 #include <calencontext.h>

    61 #include <akntoolbar.h>

    62 #include <aknstyluspopupmenu.h>

    63 #include <barsread.h>

    64 

    65 //  LOCAL CONSTANTS AND MACROS

    66 const TInt KLayoutTableGranularity(10);

    67 const TInt KNullMinutes = -1;

    68 

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

    70 

    71 // ----------------------------------------------------------------------------

    72 // CCalenDayContainer::CCalenDayContainer

    73 // C++ constructor

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

    75 // ----------------------------------------------------------------------------

    76 //

    77 CCalenDayContainer::CCalenDayContainer( CCalenNativeView* aView,

    78                                         TTime& aDate,

    79                                         TInt& aHighlightedRowNumber,

    80                                         TInt& aFirstEntryOnScreenIndex,

    81                                         MCalenServices& aServices )

    82     : CCalenContainer( aView, aServices ),

    83       iDeletedIndex( KIndexError ),

    84       iDate( aDate ),

    85       iHighlightedRowNumber( aHighlightedRowNumber ),

    86       iFirstEntryOnScreenIndex( aFirstEntryOnScreenIndex )

    87     {

    88     TRACE_ENTRY_POINT;

    89     TRACE_EXIT_POINT;

    90     }

    91 

    92 // ----------------------------------------------------------------------------

    93 // CCalenDayContainer::~CCalenDayContainer

    94 // Destructor

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

    96 // ----------------------------------------------------------------------------

    97 //

    98 CCalenDayContainer::~CCalenDayContainer()

    99     {

   100     TRACE_ENTRY_POINT;

   101 

   102     delete iListBoxModel;

   103     delete iListBox;

   104     iInstanceList.ResetAndDestroy();

   105     delete iLayoutTable;

   106     // Skin contexts

   107     delete iBackgroundSkinContext;

   108 

   109     TRACE_EXIT_POINT;

   110     }

   111 	

   112 // ---------------------------------------------------------

   113 // CCalenDayOnlyEventContainer::HandleListBoxEventL

   114 // Handle events incoming from list instance. 

   115 // ---------------------------------------------------------

   116 //

   117 void CCalenDayContainer::HandleListBoxEventL(CEikListBox* /*aListBox*/, 

   118                                                       TListBoxEvent aEventType)

   119     {

   120     TRACE_ENTRY_POINT;

   121     switch( aEventType )

   122         {

   123         // Single click integration

   124         case EEventItemSingleClicked:

   125             {

   126             //Handle listbox item selection event

   127             //iListBox->HandlePointerEventL(aPointerEvent);

   128             if(iView->MenuBar()->IsDisplayed() == EFalse)

   129                 {

   130                 iView->HandleCommandL( ECalenViewCurrentEntry );

   131                 }

   132             break;

   133             }

   134 			

   135         // Single click integration

   136         case EEventEnterKeyPressed:

   137             {

   138             iView->HandleCommandL( ECalenViewCurrentEntry );

   139             break;

   140             }

   141         default:

   142             break;

   143         };

   144     TRACE_EXIT_POINT;

   145     }

   146 	

   147 

   148 // ----------------------------------------------------------------------------

   149 // CCalenDayContainer::UpdateContainerL

   150 // Refresh Day view data and draws.

   151 // Data is based on active context.

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

   153 // ----------------------------------------------------------------------------

   154 //

   155 void CCalenDayContainer::UpdateContainerL()

   156     {

   157     TRACE_ENTRY_POINT;

   158 

   159     UpdateStatusPaneAndExtensionsL();

   160 

   161     iView->BeginRepopulationL();

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

   163 

   164     TRACE_EXIT_POINT;

   165     }

   166 

   167 // ----------------------------------------------------------------------------

   168 // CCalenDayContainer::UpdateTimeFormat

   169 // ?implementation_description

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

   171 // ----------------------------------------------------------------------------

   172 //

   173 void CCalenDayContainer::UpdateTimeFormat()

   174     {

   175     TRACE_ENTRY_POINT;

   176 

   177     SizeChanged();

   178 

   179     TRACE_EXIT_POINT;

   180     }

   181 

   182 // ----------------------------------------------------------------------------

   183 // CCalenDayContainer::DestroyInstanceListL

   184 // ?implementation_description

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

   186 // ----------------------------------------------------------------------------

   187 //

   188 void CCalenDayContainer::DestroyInstanceListL()

   189     {

   190     TRACE_ENTRY_POINT;

   191 

   192     // NULL temporary instance references in layout table

   193     for ( TInt i=0; i < iLayoutTable->Count(); ++i )

   194         {

   195         iLayoutTable->At(i).iTmpInstance = NULL;

   196         }

   197 

   198     // Destroy instances.

   199     iInstanceList.ResetAndDestroy();

   200 

   201     TRACE_EXIT_POINT;

   202     }

   203 

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

   205 // CCalenDayContainer::CreateListBoxDataL

   206 // Set Listbox data to ListBox

   207 // Step 4 of construction of ListBox data

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

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

   210 //

   211 void CCalenDayContainer::CreateListBoxDataL()

   212     {

   213     TRACE_ENTRY_POINT;

   214 

   215     MCalenContext& context = iServices.Context();

   216 	TInt aIndex = FindItemIndex( context.InstanceId() );

   217 	

   218     // ---------------------

   219     // Listbox model and view setup

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

   221 

   222     CArrayFixFlat<TInt>* cellArray = new(ELeave)CArrayFixFlat<TInt>(5);

   223     CleanupStack::PushL(cellArray);

   224 

   225     iListBoxModel->CreateListBoxDataL( *iLayoutTable,

   226                                        *cellArray,

   227                                        iServices,

   228                                        iDate );

   229 

   230     CleanupStack::Pop( cellArray );

   231     View()->SetCellArray( cellArray );

   232     

   233     UpdateHighlightedRowIfDeletedL();

   234     if(iHighlightedRowNumber!=KErrNotFound)

   235         {

   236         // Cycled to from another view when no one changed the context,

   237         // or refreshing current view. No need to set context.

   238       	if (aIndex!=KErrNotFound ) 

   239        		{

   240        		SItemInfo& itemInfo = (*iLayoutTable)[aIndex];

   241         	iHighlightedRowNumber = itemInfo.iTopLine;  

   242        		}

   243       	else if(iDeletedIndex!=KErrNotFound)

   244       	    {

   245       	    iDeletedIndex = KErrNotFound;

   246       	    }

   247       	else 

   248        	    {

   249        	    iHighlightedRowNumber = KErrNotFound;

   250        	    iFirstEntryOnScreenIndex = KErrNotFound;

   251        	    }

   252         }

   253 

   254     if(iDateWasNull) // iDate was null when population was started.

   255         {

   256         // Cycled to from another view after someone else changed the context.

   257         // Set the new highlight based on the context.

   258         SetHighlightFromContextL();

   259         }

   260     SetContextFromHighlightL();

   261 

   262     DestroyInstanceListL();

   263 

   264     iListBox->HandleItemAdditionL(); // Is this causing unnecessary draw?

   265 

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

   267     iListBox->SetFocus(ETrue);

   268     iListBox->DrawNow();

   269     DayView().UpdateCbaL();

   270 

   271     TRACE_EXIT_POINT;

   272     }

   273 

   274 // ----------------------------------------------------------------------------

   275 // CCalenDayContainer::IsEmptyView

   276 // ?implementation_description

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

   278 // ----------------------------------------------------------------------------

   279 //

   280 TBool CCalenDayContainer::IsEmptyView() const

   281     {

   282     TRACE_ENTRY_POINT;

   283 

   284     TRACE_EXIT_POINT;

   285     return (iListBox->Model()->NumberOfItems() <= 0);

   286     }

   287 

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

   289 // CCalenDayContainer::FindItem

   290 // ?implementation_description

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

   292 // ----------------------------------------------------------------------------

   293 //

   294 CCalenDayContainer::SItemInfo& CCalenDayContainer::FindItem( TInt aLineIndex ) const

   295     {

   296     TRACE_ENTRY_POINT;

   297 

   298     ASSERT( aLineIndex >= 0 );

   299 

   300     TInt itemIx = FindItemIndexForRow( aLineIndex );

   301     __ASSERT_DEBUG(itemIx >= 0, User::Invariant());

   302 

   303     SItemInfo& result = (*iLayoutTable)[itemIx];

   304 

   305     TRACE_EXIT_POINT;

   306     return result;

   307     }

   308 

   309 // ----------------------------------------------------------------------------

   310 // ?classname::?member_function

   311 // ?implementation_description

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

   313 // ----------------------------------------------------------------------------

   314 //

   315 MCalenServices& CCalenDayContainer::Services()

   316     {

   317     TRACE_ENTRY_POINT

   318     TRACE_EXIT_POINT

   319     return iServices;

   320     }

   321 

   322 // ----------------------------------------------------------------------------

   323 // ?classname::?member_function

   324 // ?implementation_description

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

   326 // ----------------------------------------------------------------------------

   327 //

   328 TInt CCalenDayContainer::FindItemIndexForRow( TInt aListIndex ) const

   329     {

   330     TRACE_ENTRY_POINT;

   331 

   332     for ( TInt i(0); i < iLayoutTable->Count(); ++i )

   333         {

   334         SItemInfo& item = (*iLayoutTable)[i];

   335         if ( item.iTopLine == aListIndex )

   336             {

   337             TRACE_EXIT_POINT;

   338             return i;

   339             }

   340         }

   341         

   342     TRACE_EXIT_POINT;

   343     return KIndexError;

   344     }

   345 

   346 // ----------------------------------------------------------------------------

   347 // CCalenDayContainer::UpdateHighlightedRowIfDeletedL

   348 // Updates the highlighted index based on whether an entry has just been

   349 // deleted.

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

   351 // ----------------------------------------------------------------------------

   352 //

   353 void CCalenDayContainer::UpdateHighlightedRowIfDeletedL()

   354     {

   355     TRACE_ENTRY_POINT;

   356 

   357     CCalenDayListBoxView* view =  View();

   358     if ( iDeletedIndex != KErrNotFound )

   359         // If just deleted an entry

   360         {

   361         if ( iLayoutTable->Count() > 0 )

   362             {

   363             // Precondition: iDeletedIndex can contain only index to first line

   364             // of deleted item.

   365             // Fixed to work as specifed in Selection Service

   366             // 2.1.1 Focus while adding or deleting items.

   367             //TInt previousLine = iDeletedIndex;

   368             //highlightLine = previousLine;

   369 

   370             iHighlightedRowNumber = iDeletedIndex-1;

   371             }

   372         else

   373             {

   374             iHighlightedRowNumber = KErrNotFound;

   375             }

   376        // iDeletedIndex = KErrNotFound;

   377         }

   378 

   379     TRACE_EXIT_POINT;

   380     }

   381 

   382 // ----------------------------------------------------------------------------

   383 // CCalenDayContainer::SetHighlightFromContextL

   384 // Sets the highlighted row based on the context.

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

   386 // ----------------------------------------------------------------------------

   387 //

   388 void CCalenDayContainer::SetHighlightFromContextL()

   389     {

   390     TRACE_ENTRY_POINT;

   391 

   392     MCalenContext& context = iServices.Context();

   393     TCalenInstanceId instId = context.InstanceId();

   394 

   395     if ( instId == TCalenInstanceId::NullInstanceId() )

   396         {

   397         iHighlightedRowNumber = 0;

   398 

   399         // Context points at a day/time, not an entry.

   400         // If we have an entry for this day set it to be the context,

   401         // as long as we weren't cycled to.

   402         if ( iLayoutTable->Count() )

   403             {

   404             if ( context.FocusTime().Int() == -1 )

   405                 {

   406                 // Context has a date but no time and no instance.

   407                 // We're not being cycled to, so set the context.

   408                 SetContextFromHighlightL();

   409                 }

   410             // else context has a date and time but no instance. This happens

   411             // for example when the week view highlights a cell with no instance,

   412             // then cycles to us - don't reset the context.

   413             }

   414 //      else Nothing on this day. Don't set context, as it's already set to this day.

   415         }

   416     else

   417         {

   418         TInt index = FindItemIndex( context.InstanceId() );

   419         if(index != KErrNotFound)

   420             {

   421             SItemInfo& itemInfo = (*iLayoutTable)[index];

   422             iHighlightedRowNumber = itemInfo.iTopLine;

   423             iFirstEntryOnScreenIndex = iListBox->TopItemIndex();

   424             SetHighlightAndVisibleItem( iHighlightedRowNumber, iFirstEntryOnScreenIndex );

   425             }

   426         }

   427 

   428     TRACE_EXIT_POINT;

   429     }

   430 

   431 // ----------------------------------------------------------------------------

   432 // CCalenDayContainer::SetContextFromHighlightL

   433 // Sets the context based on what's highlighted.

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

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

   436 //

   437 void CCalenDayContainer::SetContextFromHighlightL()

   438     {

   439     TRACE_ENTRY_POINT;

   440 

   441     MCalenContext& context = iServices.Context();

   442 	

   443     if ( iLayoutTable->Count() <= 0 )

   444         {

   445         // Nothing in the day view. Set context to this day.

   446         TCalTime dayCalTime;

   447         dayCalTime.SetTimeLocalL( iDate );

   448         context.SetFocusDateL( dayCalTime,

   449                                TVwsViewId( KUidCalendar, KUidCalenDayView ) );

   450         iHighlightedRowNumber = KErrNotFound;

   451         }

   452     else

   453         {

   454         // Stuff is present for this day.

   455      	

   456      	SetHighlightAndVisibleItem( iHighlightedRowNumber, iFirstEntryOnScreenIndex );

   457 		

   458 		TInt lineIx = iListBox->View()->CurrentItemIndex();

   459 	

   460     	// If list is empty, index is -1

   461     	if (lineIx >= 0)

   462         	{ 

   463         	TInt itemIx = FindItemIndexForRow(lineIx);

   464         	if( itemIx != KIndexError)

   465             	{

   466           		SItemInfo& item = (*iLayoutTable)[itemIx];

   467           		iHighlightedRowNumber = item.iTopLine;

   468           

   469           		if ( item.iTimedNote )

   470             		{

   471             		// Timed entry.

   472             		TCalTime dayCalTime;

   473             		dayCalTime.SetTimeLocalL( CalenDateUtils::BeginningOfDay( iDate ) + item.iStartTime );

   474             		context.SetFocusDateAndTimeAndInstanceL( dayCalTime,

   475                     		                                 item.iId,

   476                             		                         TVwsViewId( KUidCalendar, KUidCalenDayView ) );

   477             		}

   478         		else

   479             		{

   480             		// Untimed entry.

   481             		if ( item.iId.iType == CCalEntry::ETodo &&

   482                  		item.iId.iInstanceTime < CalenDateUtils::Today() )

   483                 		{

   484                 		TCalTime dayCalTime;

   485                 		dayCalTime.SetTimeLocalL( CalenDateUtils::Today() );

   486                 		// For todos in the past, set focus on the todo but view it today.

   487                 		context.SetFocusDateAndTimeAndInstanceL(

   488                         		                            dayCalTime,

   489                                 		                    item.iId,

   490                                         		            TVwsViewId( KUidCalendar, KUidCalenDayView ) );

   491                 		}

   492             		else

   493                 		{

   494                 		if ( CalenDateUtils::OnSameDay( item.iId.iInstanceTime, iDate ) )

   495                     		{

   496                     		context.SetInstanceIdL( item.iId,

   497                             		                TVwsViewId( KUidCalendar, KUidCalenDayView ) );

   498                     		}

   499                 		else

   500                     		{

   501                     		// Multi-day untimed note (either multi-day day note or weird todo).

   502                     		// Focus on the instance and set the focus time to the highlighted day.

   503                     		TCalTime dayCalTime;

   504                     		dayCalTime.SetTimeLocalL( iDate );

   505                     		context.SetFocusDateAndTimeAndInstanceL( dayCalTime,

   506                             		                                 item.iId,

   507                                                              TVwsViewId( KUidCalendar, KUidCalenDayView ) );

   508  		                   }

   509         		        }

   510             		}

   511             

   512             

   513             

   514              	}

   515         	else 

   516             	{

   517             	// FIXME: If item is not found, should we do something? 

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

   519             	}

   520         	}

   521     	else

   522         	{ // Empty list

   523         	// do nothing

   524         	}

   525         }

   526 

   527     TRACE_EXIT_POINT;

   528     }

   529 

   530 // ----------------------------------------------------------------------------

   531 // CCalenDayContainer::FindItemIndex

   532 // Returns the index into iLayoutTable of the given instance id (for highlighting).

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

   534 // ----------------------------------------------------------------------------

   535 //

   536 TInt CCalenDayContainer::FindItemIndex( const TCalenInstanceId& aId ) const

   537     {

   538     TRACE_ENTRY_POINT;

   539 

   540     // For instances finishing the next day (now possible with unified DateTime editor),

   541     // we have to do our best to match the instance time exactly - otherwise we could

   542     // match the LocalUid to the incorrect instance in a series.

   543     for(TInt index(0); index < iLayoutTable->Count(); ++index)

   544         {

   545         SItemInfo& itemInfo = (*iLayoutTable)[index];

   546 

   547         if( itemInfo.iId.iEntryLocalUid == aId.iEntryLocalUid )

   548             {

   549             // Check the instance time matches.

   550             if( itemInfo.iId.iInstanceTime == aId.iInstanceTime )

   551                 {

   552                 return index;

   553                 }

   554             }

   555         }

   556 

   557     // Couldn't match the instance time exactly - just use the instance

   558     // with the same LocalUid as the one we're looking for.

   559     // In theory this shouldn't happen but it's good to have a failsafe.

   560     for(TInt index(0); index < iLayoutTable->Count(); ++index)

   561         {

   562         SItemInfo& itemInfo = (*iLayoutTable)[index];

   563 

   564         if( itemInfo.iId.iEntryLocalUid == aId.iEntryLocalUid )

   565             {

   566             return index;

   567             }

   568         }

   569 

   570     TRACE_EXIT_POINT;

   571     return KErrNotFound;

   572     }

   573 

   574 // ----------------------------------------------------------------------------

   575 // CCalenDayContainer::SetHighlightAndVisibleItem

   576 // Sets highlight item in ListBox

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

   578 // ----------------------------------------------------------------------------

   579 //

   580 void CCalenDayContainer::SetHighlightAndVisibleItem( TInt aIndex,

   581                                                      TInt aTopItem )

   582     {

   583     TRACE_ENTRY_POINT;

   584 

   585     TInt count(iListBox->Model()->NumberOfItems());

   586     if ( count <= 0 )

   587         {

   588         return;

   589         }

   590 

   591     // aIndex and aTopItem can be indexes to any

   592     // line, not just first lines of items.

   593     // But we want to make sure that current item and top item indexes points

   594     // always only to the first line of item.

   595 

   596     // Limit range

   597     aIndex = Min(count - 1, aIndex);

   598     aIndex = Max(0, aIndex);

   599 

   600     // FIXME: can be done with layout table, no need for view-> calls  !

   601     TInt firstLine = View()->FirstLineOfCell(aIndex);

   602     iListBox->SetCurrentItemIndex(firstLine);

   603 

   604     SetVisibleLines(firstLine, aTopItem);

   605 

   606     TRACE_EXIT_POINT;

   607     }

   608 

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

   610 // ?classname::?member_function

   611 // ?implementation_description

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

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

   614 //

   615 void CCalenDayContainer::SetVisibleLines( TInt aHighlightFirstLine,

   616                                           TInt aPreferredTopLine )

   617     {

   618     TRACE_ENTRY_POINT;

   619 

   620     CCalenDayListBoxView* view =  View();

   621 

   622     TInt highLightLastLine = view->LastLineOfCell( aHighlightFirstLine );

   623 

   624     TInt maxVisibleLines = view->NumberOfItemsThatFitInRect( view->ViewRect() );

   625     TInt totalListLines = iListBox->Model()->NumberOfItems();

   626 

   627     // Initial top line

   628     TInt topLine = aPreferredTopLine == KIndexError ? aHighlightFirstLine : aPreferredTopLine;

   629     topLine = Min(totalListLines - 1, topLine);

   630     topLine = Max(0, topLine);

   631 

   632     if ( aHighlightFirstLine < topLine )

   633         {

   634         topLine = aHighlightFirstLine;

   635         }

   636 

   637     // Adjust bottom line

   638     TInt bottomLine = topLine + maxVisibleLines - 1;

   639     TInt lastListLine = totalListLines - 1;

   640     bottomLine = bottomLine > lastListLine ? lastListLine : bottomLine;

   641     if ( highLightLastLine > bottomLine )

   642         {

   643         bottomLine = highLightLastLine;

   644         }

   645 

   646     TInt currentlyVisibleLines = bottomLine - topLine + 1;

   647     if ( currentlyVisibleLines > maxVisibleLines )

   648         {

   649         topLine = bottomLine - maxVisibleLines + 1;

   650         }

   651     // Now we have ensured that highlight is between [topLine, bottomLine]

   652     // If there are room for more lines in display, and still more lines

   653     // in list, we can scroll view up

   654 

   655     currentlyVisibleLines = bottomLine - topLine + 1;

   656     if ( (currentlyVisibleLines < maxVisibleLines - 1)

   657          && (totalListLines >= currentlyVisibleLines))

   658         {

   659         topLine = bottomLine - maxVisibleLines + 1;

   660         topLine = topLine < 0 ? 0 : topLine;

   661         }

   662 

   663     iListBox->SetTopItemIndex( topLine );

   664 

   665     TRACE_EXIT_POINT;

   666     }

   667 

   668 // ---------------------------------------------------------

   669 // CCalenDayContainer::SearchNearestItem

   670 // Searches list item that is nearest to aTime

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

   672 // ---------------------------------------------------------

   673 //

   674 TInt CCalenDayContainer::SearchNearestItem( TTimeIntervalMinutes aTime ) const

   675     {

   676     TRACE_ENTRY_POINT;

   677 

   678     TInt foundIndex( KIndexError );

   679     const TInt count( iLayoutTable->Count() );

   680 

   681     for( TInt index(0); index < count; ++index )

   682         {

   683         SItemInfo& itemInfo = (*iLayoutTable)[index];

   684 

   685         // times match

   686         if( itemInfo.iStartTime == aTime )

   687             {

   688             foundIndex = index;

   689             break;

   690             }

   691         // times fall into same hour

   692         else if( (itemInfo.iStartTime.Int()/KCalenMinutesInHour) == (aTime.Int() / KCalenMinutesInHour)

   693                  && foundIndex == KIndexError )

   694             {

   695                 // Same starting hour

   696                 foundIndex = index;

   697             }

   698         }

   699 

   700     TRACE_EXIT_POINT;

   701     return foundIndex;

   702     }

   703 

   704 // ----------------------------------------------------------------------------

   705 // CCalenDayContainer::SizeChanged

   706 // Resizes child controls

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

   708 // ----------------------------------------------------------------------------

   709 //

   710 void CCalenDayContainer::SizeChanged()

   711     {

   712     TRACE_ENTRY_POINT;

   713 

   714     CCalenContainer::SizeChanged( Rect() );

   715     

   716     TRAPD(error,iLayoutManager->GetLayoutAndExtensionL());

   717     if(error!=KErrNone)

   718     	{

   719     	// do avoid warning

   720     	}

   721               

   722     // Find the layout variant based upon a preview pane building present or not.

   723     TInt layoutVariant = LayoutVariantIndex( EListScrollCaleDayPane );

   724        

   725     TAknLayoutRect main_cale_day_pane;

   726     main_cale_day_pane.LayoutRect( Rect(), 

   727                     AknLayoutScalable_Apps::main_cale_day_pane(0).LayoutLine() );

   728         

   729     TAknLayoutRect listscroll_cale_day_pane;

   730     listscroll_cale_day_pane.LayoutRect( main_cale_day_pane.Rect(), 

   731             AknLayoutScalable_Apps::listscroll_cale_day_pane( layoutVariant ).LayoutLine() );

   732     

   733 

   734 #ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

   735     PIM_TRAPD_HANDLE(GetMidnightVisualizationL()) // sets iMidnight

   736 #endif // RD_CALEN_MIDNIGHT_VISUALIZATION

   737 

   738 

   739     iListBoxModel->UpdateLayoutValues( layoutVariant

   740 #ifdef RD_CALEN_MIDNIGHT_VISUALIZATION

   741         , iMidnight

   742 #endif // RD_CALEN_MIDNIGHT_VISUALIZATION

   743         );

   744 

   745     // Now get the correct version for if we have a info bar or not

   746     listscroll_cale_day_pane.LayoutRect( main_cale_day_pane.Rect(), AknLayoutScalable_Apps::listscroll_cale_day_pane(layoutVariant).LayoutLine() );

   747 

   748 

   749     layoutVariant = LayoutVariantIndex( EBgCalePane );

   750 

   751     TAknLayoutRect bg_cale_pane;

   752     bg_cale_pane.LayoutRect( listscroll_cale_day_pane.Rect(), AknLayoutScalable_Apps::bg_cale_pane( layoutVariant ).LayoutLine() );

   753 

   754     TAknLayoutRect cale_bg_pane_center;

   755     cale_bg_pane_center.LayoutRect( bg_cale_pane.Rect(), AknLayoutScalable_Apps::cale_bg_pane_g1().LayoutLine() );

   756 

   757     iBackgroundSkinContext->SetFrameRects( bg_cale_pane.Rect(), cale_bg_pane_center.Rect() );

   758     iBackgroundSkinContext->SetParentContext( iBgContext );

   759 

   760     // Listbox layout

   761     TAknLayoutRect list_cale_pane;

   762     list_cale_pane.LayoutRect( main_cale_day_pane.Rect(), AknLayoutScalable_Apps::list_cale_pane( layoutVariant ).LayoutLine() );

   763 

   764     iListBox->SetRect( list_cale_pane.Rect() );

   765 

   766     // Inside of listbox.

   767     iListBox->ItemDrawer()->FormattedCellData()->SetBackgroundSkinStyle( &KAknsIIDQsnFrCaleCenter, cale_bg_pane_center.Rect() );

   768     layoutVariant = LayoutVariantIndex( EScrollPaneCp09 );

   769     // Scrollbar layout

   770     AknLayoutUtils::LayoutVerticalScrollBar( iListBox->ScrollBarFrame(),

   771                                              listscroll_cale_day_pane.Rect(),

   772                                              AknLayoutScalable_Apps::scroll_pane_cp09( layoutVariant ).LayoutLine() );

   773     

   774    

   775        

   776     PIM_TRAPD_HANDLE( UpdateStatusPaneAndExtensionsL() )

   777     

   778     CCoeControl* infoControl = iLayoutManager->ControlOrNull();

   779     if(infoControl)

   780     	{

   781     	TRAP_IGNORE(infoControl->ActivateL());

   782     	}

   783         

   784     

   785     DrawNow();

   786     TRACE_EXIT_POINT;

   787     }

   788 

   789 // ----------------------------------------------------------------------------

   790 // CCalenDayContainer::FocusChanged

   791 // ?implementation_description

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

   793 // ----------------------------------------------------------------------------

   794 //

   795 void CCalenDayContainer::FocusChanged( TDrawNow aDrawNow )

   796     {

   797     TRACE_ENTRY_POINT;

   798 

   799     CCalenContainer::FocusChanged( aDrawNow );

   800 

   801     if( iListBox )

   802         {

   803         iListBox->SetFocus( IsFocused() );

   804         }

   805 

   806     TRACE_EXIT_POINT;

   807     }

   808 

   809 // ----------------------------------------------------------------------------

   810 // CCalenDayContainer::UpdateIconsL

   811 // update icons

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

   813 // ----------------------------------------------------------------------------

   814 //

   815 void CCalenDayContainer::UpdateIconsL()

   816     {

   817     TRACE_ENTRY_POINT;

   818     

   819     CAknIconArray* iconList = CreateIconsL( iIconIndices );

   820     if(iListBox)

   821     {

   822     CArrayPtr<CGulIcon>* iconArray =iListBox->ItemDrawer()->FormattedCellData()->IconArray();

   823     delete iconArray;

   824     iconArray = NULL;

   825     iListBox->ItemDrawer()->ColumnData()->SetIconArray( iconList );

   826     }

   827     

   828     TRACE_EXIT_POINT;

   829     }

   830     

   831 // ----------------------------------------------------------------------------

   832 // CCalenDayContainer::HandleResourceChange

   833 // Called when layout or skin changes

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

   835 // ----------------------------------------------------------------------------

   836 //

   837 void CCalenDayContainer::HandleResourceChange( TInt aType )

   838     {

   839     TRACE_ENTRY_POINT;

   840 

   841     CCalenContainer::HandleResourceChange( aType );

   842 

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

   844         {

   845         TRAPD(error,UpdateIconsL());

   846 	    if(error!=KErrNone)

   847 	       	{

   848 	       	// do avoid warning

   849 	       	}     

   850         // refresh

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

   852 	    if(err!=KErrNone)

   853 	       	{

   854 	       	// do avoid warning

   855 	       	}

   856 	    SizeChanged();

   857 

   858 	            // Update date formats to status pane

   859 	    TRAP_IGNORE(UpdateStatusPaneAndExtensionsL());

   860 

   861         }

   862 

   863     CCoeControl::HandleResourceChange( aType );

   864 

   865     TRACE_EXIT_POINT;

   866     }

   867 

   868 // ----------------------------------------------------------------------------

   869 // CCalenDayContainer::CountComponentControls

   870 // Gets child control count

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

   872 // ----------------------------------------------------------------------------

   873 TInt CCalenDayContainer::CountComponentControls() const

   874     {

   875     TRACE_ENTRY_POINT;

   876     

   877     TInt controlCount;

   878 

   879     if ( iLayoutManager->ControlOrNull() )

   880         {

   881         controlCount = 2;

   882         }

   883     else

   884         {

   885         controlCount = 1;

   886         }

   887 

   888     TRACE_EXIT_POINT;

   889     return controlCount;

   890     }

   891 

   892 // ----------------------------------------------------------------------------

   893 // CCalenDayContainer::ComponentControl

   894 // Gets child control pointer

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

   896 // ----------------------------------------------------------------------------

   897 CCoeControl* CCalenDayContainer::ComponentControl(TInt aIndex) const

   898     {

   899     TRACE_ENTRY_POINT;

   900 

   901     CCoeControl* control( NULL );

   902 

   903     switch (aIndex)

   904         {

   905         case 0:

   906             control = iListBox;

   907             break;

   908         

   909         case 1:

   910             control = iLayoutManager->ControlOrNull();

   911             break;

   912         

   913         default:

   914             __ASSERT_DEBUG( 0, User::Invariant() );

   915             break;

   916         }

   917 

   918     TRACE_EXIT_POINT;

   919     return control;

   920     }

   921 

   922 // ----------------------------------------------------------------------------

   923 // CCalenDayContainer::OfferKeyEventL

   924 // Process key event

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

   926 // ----------------------------------------------------------------------------

   927 //

   928 TKeyResponse CCalenDayContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,

   929                                                           TEventCode aType )

   930     {

   931     TRACE_ENTRY_POINT;

   932 

   933     // common view key handling

   934     if (CCalenContainer::OfferKeyEventL(aKeyEvent, aType) == EKeyWasConsumed)

   935         {

   936         return EKeyWasConsumed;

   937         }

   938 

   939     // day view specific key handling

   940     TKeyResponse exitCode(EKeyWasNotConsumed);

   941 

   942     if (aType == EEventKey)

   943         {

   944         TBool mirrored(AknLayoutUtils::LayoutMirrored());

   945         switch (aKeyEvent.iCode)

   946             {

   947             case EKeyLeftArrow:

   948                 {

   949                 HandleHorizontalScrollL(TTimeIntervalDays(mirrored ? 1 : -1));

   950                 exitCode = EKeyWasConsumed;

   951                 break;

   952                 }

   953             case EKeyRightArrow:

   954                 {

   955                 HandleHorizontalScrollL(TTimeIntervalDays(mirrored ? -1 : 1));

   956                 exitCode = EKeyWasConsumed;

   957                 break;

   958                 }

   959             case EKeyBackspace:

   960                 {

   961                  // Single click integration

   962                 if( iView->MenuBar()->ItemSpecificCommandsEnabled()

   963                         && !IsEmptyView() )

   964 	                {

   965 	                iView->HandleCommandL( ECalenDeleteCurrentEntry );

   966 	                exitCode = EKeyWasConsumed;

   967 	                }

   968                 break;

   969                 }

   970             case EKeyOK:

   971                 {

   972                 if(iListBox->Model()->NumberOfItems() > 0)

   973                     {

   974                      // Single click integration

   975                     iListBox->OfferKeyEventL( aKeyEvent, aType );

   976                     }

   977                 else

   978                     {

   979                     CEikMenuBar* menuBar = iView->MenuBar();

   980                     menuBar->SetContextMenuTitleResourceId( R_CALENDAR_DAY_CASE_MENUBAR );

   981                     menuBar->TryDisplayContextMenuBarL();

   982                     }

   983                 exitCode = EKeyWasConsumed;

   984                 break;

   985                 }

   986             case EKeyEnter:    

   987         		{

   988         		if(IsEmptyView())

   989                    	{ 

   990                    	iView->HandleCommandL(ECalenCmdOpenMskDialog);                    

   991                     }

   992                 else

   993 	                {

   994                      // Single click integration

   995                     iListBox->OfferKeyEventL( aKeyEvent, aType );

   996 	            	}

   997          		exitCode = EKeyWasConsumed;	

   998                 break;

   999         		}

  1000             default:

  1001                 break;

  1002             }

  1003         }

  1004 

  1005 	// For handling geokeys on corolla hardware

  1006 	// For Add location hard key

  1007 	if( aKeyEvent.iScanCode == EStdKeyApplication1C && aType == EEventKeyUp )

  1008 		{

  1009          // Single click integration

  1010         if( iView->MenuBar()->ItemSpecificCommandsEnabled()

  1011                 && CCalenLocationUtil::IsMapProviderAvailableL() )

  1012 			{

  1013 			MCalenContext& context = iServices.Context();

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

  1015 			CCalEntry* entry = iServices.EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);

  1016 			CleanupStack::PushL( entry );

  1017 			if(entry)

  1018 				{

  1019 				CCalEntry::TType entryType = entry->EntryTypeL();

  1020 				if(entryType == CCalEntry::EAppt)

  1021 					{

  1022 					iServices.IssueCommandL(ECalenGetLocationAndSave);

  1023 					}

  1024 				}

  1025 			CleanupStack::PopAndDestroy( entry );

  1026 			}

  1027 		exitCode = EKeyWasConsumed;

  1028 		}

  1029 	// For Show location hard key

  1030     // Single click integration 

  1031     else if( aKeyEvent.iScanCode == EStdKeyApplication1B && aType == EEventKeyUp

  1032             && iView->MenuBar()->ItemSpecificCommandsEnabled() )

  1033 		{

  1034 		MCalenContext& context = iServices.Context();

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

  1036 		

  1037 		CCalEntry* entry = iServices.EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);

  1038 		CleanupStack::PushL( entry );

  1039 		if(entry)

  1040 			{

  1041 			CCalEntry::TType entryType = entry->EntryTypeL();

  1042 			if(entryType == CCalEntry::EAppt)

  1043 				{

  1044 				TPtrC location = entry->LocationL();

  1045 				if( entry->GeoValueL())

  1046 					{ 

  1047 					iServices.IssueCommandL(ECalenShowLocation);

  1048 					}

  1049 				else if(location.Length())

  1050 					{

  1051 					iServices.IssueCommandL(ECalenGetLocationAndReplace);

  1052 					}

  1053 				else

  1054 					{

  1055 					iServices.IssueCommandL(ECalenShowLocationQuery);

  1056 					}

  1057 				}

  1058 			}

  1059 		CleanupStack::PopAndDestroy( entry );

  1060 		}

  1061 		

  1062     // listbox key handling

  1063     if (exitCode == EKeyWasConsumed || !iListBox)

  1064         {        // if DoDeactivate() is done, iListBox will be NULL.

  1065         // do nothing

  1066         }

  1067     else

  1068         {

  1069         TInt oldCursor = iListBox->View()->CurrentItemIndex();

  1070         exitCode = iListBox->OfferKeyEventL( aKeyEvent, aType );

  1071         TInt newCursor = iListBox->View()->CurrentItemIndex();

  1072         if (oldCursor != newCursor)

  1073             {

  1074             HandleVerticalScrollL( newCursor );

  1075             }

  1076         }

  1077 

  1078     TRACE_EXIT_POINT;

  1079     return exitCode;

  1080     }

  1081 

  1082 // ----------------------------------------------------------------------------

  1083 // CCalenDayContainer::HandleHorizontalScrollL

  1084 // Handles moving left or right to a new day.

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

  1086 // ----------------------------------------------------------------------------

  1087 //

  1088 void CCalenDayContainer::HandleHorizontalScrollL( TTimeIntervalDays aDirection )

  1089     {

  1090     TRACE_ENTRY_POINT;

  1091 

  1092     TTime time = CalenDateUtils::BeginningOfDay( iDate + aDirection );

  1093     time += iServices.Context().DefaultTimeForViews();

  1094 

  1095     if ( CalenDateUtils::IsValidDay( time ) )

  1096         {

  1097         iDate = time;

  1098         iHighlightedRowNumber = KErrNotFound;

  1099         iFirstEntryOnScreenIndex = KErrNotFound;

  1100 

  1101         // set the idate in to context

  1102         TCalTime time;

  1103         time.SetTimeLocalL( iDate );

  1104         iServices.Context().SetFocusDateL( time,

  1105                          TVwsViewId( KUidCalendar, KUidCalenDayView ) );

  1106 

  1107         UpdateContainerL(); // Repopulate.

  1108         }

  1109     else

  1110         {

  1111         CalenViewUtils::ShowDateOutOfRangeErrorNoteL();

  1112         }

  1113 

  1114     TRACE_EXIT_POINT;

  1115     }

  1116 

  1117 // ----------------------------------------------------------------------------

  1118 // CCalenDayContainer::HandleVerticalScrollL

  1119 // Handles moving up or down in the same day.

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

  1121 // ----------------------------------------------------------------------------

  1122 //

  1123 void CCalenDayContainer::HandleVerticalScrollL( TInt aNewCursor )

  1124     {

  1125     TRACE_ENTRY_POINT;

  1126 

  1127     iHighlightedRowNumber = aNewCursor;

  1128     ASSERT( iHighlightedRowNumber >= 0 );

  1129     iFirstEntryOnScreenIndex = iListBox->TopItemIndex();

  1130     SetContextFromHighlightL();

  1131 

  1132     TRACE_EXIT_POINT;

  1133     }

  1134