/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Container control for Week View .

 *

*/

#include <calcommon.h>

#include <caltime.h>

#include <calinstance.h>

#include <calentry.h>

#include <calinstanceview.h>

#include <calcalendarinfo.h>

#include <AknIconArray.h>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <eikenv.h>

#include <eikfrlbd.h>

#include <eiklabel.h>

#include <gulicon.h>

#include <StringLoader.h>

#include <calencontext.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <layoutmetadata.cdl.h>

#include <centralrepository.h>

#include <calenviewutils.h>

#include <calenservices.h>

#include <calenagendautils.h>

#include <calendateutils.h>

#include <mcalenpreview.h>

#include <Calendar.rsg>

#include <csxhelp/cale.hlp.hrh>

#include "calendarui_debug.h"

#include "calenweekcontainer.h"

#include "calencontainerlayoutmanager.h"

#include "calencontroller.h"

#include "calendrawutils.h"

#include "calenicons.h"

#include "calenpreview.h"

#include "CalenUid.h"

#include "CalendarPrivateCRKeys.h"

#include "calenweeklistboxview.h"

#include "calenweeklistbox.h"

#include "calenweeklistboxlayout.h"

#include "calenweekview.h"

#include "CalenUid.h"

#include "calendar.hrh"

//  LOCAL CONSTANTS AND MACROS

const TInt KNonTimedNoteDefautDisplayTime(8);

const TInt KNullMinutes = -1;

const TInt KBeforeActiveTime(0);

const TInt KHoursInADay( 24 );

// METHOD DEFINITIONS

// ----------------------------------------------------------------------------

// ?classname::?member_function

// ?implementation_description

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::DrawBackground(CWindowGc& aGc) const

    {

    TRACE_ENTRY_POINT;

    MAknsControlContext* cc =AknsDrawUtils::ControlContext( this );

    if( cc )

        {

        TRect main_pane( Rect() );

        AknsDrawUtils::Background( AknsUtils::SkinInstance(),

                                   cc,

                                   NULL,

                                   aGc,

                                   main_pane );

        }

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// Draws horizontal and vertical grid lines

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::DrawGridLines(CWindowGc& aGc) const

    {

    TRACE_ENTRY_POINT;

    TRect main_pane_Rect = ReducePreview( Rect() );

    TAknLayoutRect main_cale_week_pane;

    main_cale_week_pane.LayoutRect( main_pane_Rect, AknLayoutScalable_Apps::main_cale_week_pane().LayoutLine() );

    // FIXME: use member variable?

    TAknLayoutRect listscroll_cale_week_pane;

    TWeekListBoxLayout lay( UseInfobar(), UseToolbar(), UsePreview(), main_pane_Rect );

    TInt layoutVariant = lay.LayoutVariantIndex(TWeekListBoxLayout::EListScrollCaleWeekPane );

    listscroll_cale_week_pane.LayoutRect( main_cale_week_pane.Rect(), AknLayoutScalable_Apps::listscroll_cale_week_pane(layoutVariant).LayoutLine() );

    layoutVariant = lay.LayoutVariantIndex(TWeekListBoxLayout::ECaleWeekScrollPaneG1);

    const TRect parentRect = listscroll_cale_week_pane.Rect();

    // Primary lines were drawn in different functions

    TAknLayoutRect horizontalPrimaryLine;

    horizontalPrimaryLine.LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g1( layoutVariant ).LayoutLine() );

    TAknLayoutRect verticalPrimaryLine;

    verticalPrimaryLine.LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g2( layoutVariant ).LayoutLine() );

    TRgb lineColor( verticalPrimaryLine.Color() );

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), lineColor,

                              KAknsIIDQsnLineColors,

                              EAknsCIQsnLineColorsCG1);

    aGc.SetBrushColor( lineColor );

    aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

    aGc.Clear( verticalPrimaryLine.Rect() );

    aGc.Clear( horizontalPrimaryLine.Rect() );

    // There are six secondary vertical lines

    const TInt verticalLineCount = 6;

    TAknLayoutRect verticalLines[ verticalLineCount ];

    verticalLines[0].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g3( layoutVariant ).LayoutLine() );

    verticalLines[1].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g4( layoutVariant ).LayoutLine() );

    verticalLines[2].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g5( layoutVariant ).LayoutLine() );

    verticalLines[3].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g6( layoutVariant ).LayoutLine() );

    verticalLines[4].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g7( layoutVariant ).LayoutLine() );

    verticalLines[5].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g8( layoutVariant ).LayoutLine() );

    // and seven secondary horizontal lines

    const TInt horizontalLineCount = 7;

    TAknLayoutRect horizontalLines[ horizontalLineCount ];

    horizontalLines[0].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g9( layoutVariant ).LayoutLine() );

    horizontalLines[1].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g10( layoutVariant ).LayoutLine() );

    horizontalLines[2].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g11( layoutVariant ).LayoutLine() );

    horizontalLines[3].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g12( layoutVariant ).LayoutLine() );

    horizontalLines[4].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g13( layoutVariant ).LayoutLine() );

    horizontalLines[5].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g14( layoutVariant ).LayoutLine() );

    horizontalLines[6].LayoutRect( parentRect, AknLayoutScalable_Apps::cale_week_scroll_pane_g15( layoutVariant ).LayoutLine() );

    lineColor = verticalLines[0].Color();

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), lineColor,

                              KAknsIIDQsnLineColors,

                              EAknsCIQsnLineColorsCG2);

    aGc.SetBrushColor( lineColor );

    aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

    for (TInt i=0; i < verticalLineCount; ++i)

        {

        aGc.Clear( verticalLines[i].Rect() );

        }

    for (TInt i=0; i < horizontalLineCount; ++i)

        {

        aGc.Clear( horizontalLines[i].Rect() );

        }

    TRACE_EXIT_POINT;

    }

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

// ----------------------------------------------------------------------------

// CCalenWeekContainer::CCalenWeekContainer

// C++ constructor can NOT contain any code, that might leave.

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

// ----------------------------------------------------------------------------

//

CCalenWeekContainer::CCalenWeekContainer( CCalenNativeView* aView,

                                          TTime& aTime,

                                          TInt& aSelectedRowNumber,

                                          TTimeIntervalMinutes& aFirstRowTime,

                                          MCalenServices& aServices )

    : CCalenContainer( aView, aServices ),

//      iCurrentDay( TInt64(0) ),

      iStartDay( TInt64(0) ),

      iViewPopulationComplete( EFalse ),

      iTime( aTime ),

      iSelectedRowNumber( aSelectedRowNumber ),

      iFirstRowTime( aFirstRowTime )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::~CCalenWeekContainer

// Destructor

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

// ----------------------------------------------------------------------------

//

CCalenWeekContainer::~CCalenWeekContainer()

    {

    TRACE_ENTRY_POINT;

    delete iListBox;

    if( iNativePreview && iPreview )

        {

        delete iPreview;

        iPreview = NULL;

        }

    delete iDesArray;

    CleanupInstances();

    ResetSlotTable();

    delete iBackgroundSkinContext;

    TRACE_EXIT_POINT;

    }

// ---------------------------------------------------------

// CCalenWeekContainer::SetCursorToActiveDayL

// Sets cursor in Active day

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::SetCursorToActiveDayL()

    {

    TRACE_ENTRY_POINT;

    iTime = CCalenContainer::DateFromContextL( iServices.Context() );

    TLocale locale;

    TInt column( iTime.DayNoInWeek() - locale.StartOfWeek() );

    if( column < 0 )

        {

        column += KCalenDaysInWeek;

        }

    iColumn = column;

    TTime startDay( iTime - TTimeIntervalDays( column ) );

    if (iStartDay != startDay)

        {

        iStartDay = startDay;

        iView->BeginRepopulationL();

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

        }

    else if ( iViewPopulationComplete )

        {

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

        SelectHighlightedCellAndVisibleRangeL();

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

        FocusChangeForPopupL();

        UpdateStatusPaneAndExtensionsL();

        DrawNow();

        }

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::RedrawLocaleChangeL

// Redrawing when locale change

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::RedrawLocaleChangeL(TLocaleChangeRedraw aFlag) // ERedrawAll | ERedrawWeek

    {

    TRACE_ENTRY_POINT;

    if (aFlag == ERedrawAll)

        {

        iStartDay = Time::NullTTime();

        SetCursorToActiveDayL();

        }

    FocusChangeForPopupL();    

    UpdateStatusPaneAndExtensionsL();

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// ?classname::?member_function

// ?implementation_description

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

// ----------------------------------------------------------------------------

//

TInt CCalenWeekContainer::HighlightRowFromActiveContextL(TInt aColumn)

    {

    TRACE_ENTRY_POINT;

    TInt row = KErrNotFound;

    MCalenContext& context = iServices.Context();

    // row is selected while moving up/dowm left/right

    if ( iSelectedRowNumber != KErrNotFound )  

       {

        row = iSelectedRowNumber;

        iFirstRowTime = context.FocusTime();

		if(iFirstRowTime != TTimeIntervalMinutes(KNullMinutes))

			{

			iRow = EFalse;

			}

		else

			{

			iRow = ETrue;

			row = FindItemFromColumnL( context.InstanceId(),aColumn );

			}

		if(iFirstRowTime == TTimeIntervalMinutes(0))

			{

			row = KErrNotFound;

			iFirstRowTime = TTimeIntervalMinutes(KNullMinutes);

			}

        }

     else if ( !(context.InstanceId() == TCalenInstanceId::NullInstanceId() ) )

        {

        // based on the instanceid

        row = FindItemFromColumnL( context.InstanceId(),

                                          aColumn );

        }

     else if ( context.FocusDateAndTimeL().TimeUtcL() != Time::NullTTime() )

        {

        // weekview is activated from other views/view switching

        if(	iSelectedRowNumber == KErrNotFound && 

        	iFirstRowTime == TTimeIntervalMinutes(KNullMinutes)  )

        	{

        	row = KErrNotFound;

        	}

        else

        	{

        	// based on the context time

        	row = FindRowForTime(

            	    CalenDateUtils::RoundToPreviousHour(

                	CalenDateUtils::TimeOfDay(

                    context.FocusDateAndTimeL().TimeLocalL().DateTime() ) ) );

        	}

        }

    // if we still haven't found anything to highlight,

    // highlight to first entry or 8:00 row.

    if (row == KErrNotFound)

        {

        row = FindFirstItemOfColumn(aColumn);

        if (row == KErrNotFound)

            {

            TInt eightOclock = KNonTimedNoteDefautDisplayTime * KCalenMinutesInHour;

            row = FindRowForTime( eightOclock );

            iTopRowDefault = ETrue;

            }

        }

    ASSERT( row != KErrNotFound );

	TRACE_EXIT_POINT;

    return row;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::SelectHighlightedCellAndVisibleRangeL()

// Sets highlight item in ListBox at active time

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::SelectHighlightedCellAndVisibleRangeL()

    {

    TRACE_ENTRY_POINT;

    TInt row = HighlightRowFromActiveContextL( iColumn );

	TInt topRow = SearchTopIndexL( iColumn );

    if (row == KErrNotFound)

        {

        // If not yet found, Then just take 8:00 row

        TInt eightOclock = KNonTimedNoteDefautDisplayTime * KCalenMinutesInHour;

        row = FindRowForTime(eightOclock);

        }

    SetHighlightAndVisibleRange( row, iColumn, topRow );

	SetActiveContextFromHighlightL();

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::SetActiveContextFromHighlightL

// Set Active date and time

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::SetActiveContextFromHighlightL()

    {

    TRACE_ENTRY_POINT;

    MCalenContext& context = iServices.Context();

    TCalTime currentDayCalTime;

    TDateTime dt = iTime.DateTime();

    currentDayCalTime.SetTimeLocalL( iTime );

    context.SetFocusDateAndTimeL( currentDayCalTime,

                                  TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

    TInt row = iListBox->View()->CurrentItemIndex();

    // In under processing of DoStepL(), row is -1.

    if (row >= 0)

        {

        CWeekSlotArrayPtr slotTable = iSlotTable[iColumn];

        const CCalHourItem& itemInfo = *(*slotTable)[row];

        // Focused item

        // 1. Non-timed item, 1 for each cell, on same/ different day

        //    * Focus on instanceId and datetime

        // 2. Timed item, 1-n for each cell, on same/ different day

        //    * Focus on datetime

        if( itemInfo.HasInstance() )

            {

            TCalenInstanceId instId = TCalenInstanceId::CreateL( *itemInfo.iInstance );

            if( !itemInfo.IsTimed() )       // todo/anniv/memo

                {

                dt.SetHour( KNonTimedNoteDefautDisplayTime );

                currentDayCalTime.SetTimeLocalL( TTime( dt ) );

                context.SetFocusDateAndTimeAndInstanceL( currentDayCalTime, instId, 

                                                TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

                }

            else    // meeting

                {

                TTime focusTime = CalenDateUtils::BeginningOfDay( iTime ) + itemInfo.iStartTime;

                currentDayCalTime.SetTimeLocalL( focusTime );

 //               context.SetFocusDateAndTimeL( currentDayCalTime,

  //                                              TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

                context.SetFocusDateAndTimeAndInstanceL( currentDayCalTime, instId, 

                                                TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

                TDateTime focusTimeTemp = focusTime.DateTime();

                }

            }

        else if( itemInfo.iStartTime.Int() == KErrNotFound )    // empty non-timed cell

            {

            dt.SetHour( KNonTimedNoteDefautDisplayTime );

            currentDayCalTime.SetTimeLocalL( TTime( dt ) );

            context.SetFocusDateAndTimeL( currentDayCalTime,

                                                TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

            }

        else    // empty timed cell

            {

            TTime focusTime = CalenDateUtils::BeginningOfDay( iTime ) + itemInfo.iStartTime;

            currentDayCalTime.SetTimeLocalL( focusTime );

            context.SetFocusDateAndTimeL( currentDayCalTime,

                                                TVwsViewId( KUidCalendar, KUidCalenWeekView ) );

            }

        FocusChangeForPopupL();

        }

	// Hide/unhide "today" toolbar item based on the focused day

    UpdateTodayToolbarItemL();

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::CalcDayFromColumn

// Calculates and Sets day from ListBox column

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::CalcDayFromColumn()

    {

    TRACE_ENTRY_POINT;

    iTime = iStartDay + TTimeIntervalDays( iColumn );

    TDateTime dt = iStartDay.DateTime();

    TRACE_EXIT_POINT;

    }

// ----------------------------------------------------------------------------

// CCalenWeekContainer::PopulatesDayListsL

// Populate whole week daylist from Agenda server

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

// ----------------------------------------------------------------------------

//

void CCalenWeekContainer::PopulatesDayListsL()

    {

    TRACE_ENTRY_POINT;

    TTime indexDay( iStartDay );

    TTimeIntervalDays oneDay( 1 );

    RArray<TInt> colIdArray;

    CCalenNativeView::GetActiveCollectionidsL( iServices, colIdArray );

    if(colIdArray.Count() > 0)

         {    

         for( TInt i(0); i < KCalenDaysInWeek; ++i, indexDay+=oneDay )

            {

            iIdList[i].ResetAndDestroy();

            CalenAgendaUtils::CreateEntryIdListForDayL( iIdList[i],

                                                        iServices.InstanceViewL(colIdArray),

                                                        indexDay );

            }

         }

     else

         {

         for( TInt i(0); i < KCalenDaysInWeek; ++i, indexDay+=oneDay )

             {

             iIdList[i].ResetAndDestroy();

             CalenAgendaUtils::CreateEntryIdListForDayL( iIdList[i],

                                                         iServices.InstanceViewL(),

                                                         indexDay );

             }

         }