/*

* Copyright (c) 2008 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 for missed alarm view's controls.

 *

*/

// System Includes

#include <StringLoader.h>

#include <eikdef.h>

#include <eikenv.h>

#include <avkon.rsg>

#include <AknUtils.h>

#include <aknlists.h>

#include <AknsUtils.h>

#include <AknIconArray.h>

#include <avkon.hrh>

#include <aknconsts.h>

#include <data_caging_path_literals.hrh>

#include <AknIconArray.h>

#include <AknsDrawUtils.h>

#include <avkon.mbg>

#include <gulicon.h>

#include <aknenv.h>

#include <eikapp.h>

#include <AknBidiTextUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <AknsFrameBackgroundControlContext.h>

#include <csxhelp/cale.hlp.hrh>

#include <calentryview.h>

#include <calsession.h>

#include <calinstanceview.h>

#include <calinstance.h>

#include <missedalarmstore.h>

#include <missedalarm.h>

#include <calenagendautils.h>

#include <calenglobaldata.h>

#include <calendar.mbg>

#include <Calendar.rsg>

#include <calencommands.hrh>            // Calendar commands

#include <calencontext.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <calenservices.h>

#include <calentoolbar.h>

#include <calenviewutils.h>

// User Includes

#include "calendarui_debug.h"

#include "calenmissedalarmscontainer.h"

#include "calendar.hrh"

#include "calencontainer.h"

#include "calenicons.h"

#include "calenicons.h"

#include "CalenUid.h"

// Constants

const TInt KMissedAlarmListMaxLength = 25;

const TInt KMissedAlarmListBoxItems = 10;

const TInt KListDataLength = 256;

_LIT( KListSeparator, "\t" );

_LIT( KIconFormat,"%d");

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

// CCalenMissedAlarmsContainer::CCalenMissedAlarmsContainer

// Performs the first phase of two phase construction.

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

//

CCalenMissedAlarmsContainer::CCalenMissedAlarmsContainer(CCalenNativeView* aView,

                         MCalenServices& aServices,TInt& aHighlightedRowNumber) :

    CCalenContainer(aView, aServices),

    iHighlightedRowNumber(aHighlightedRowNumber)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::~CCalenMissedAlarmsContainer

// Destructor

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

//

CCalenMissedAlarmsContainer::~CCalenMissedAlarmsContainer()

    {

    TRACE_ENTRY_POINT;

    if(iListBoxItemArray)

        {

        delete iListBoxItemArray;

        }

    if(iMissedAlarmsArray.Count())

        {

        iMissedAlarmsArray.Reset();

        iMissedAlarmsArray.Close();

        }

    if (iListBox)

        {

        delete iListBox;

        iListBox = NULL;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::ConstructImplL

// Third phase constructor.

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

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

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

//

void CCalenMissedAlarmsContainer::ConstructImplL()

    {

    TRACE_ENTRY_POINT;

    iListBoxItemArray = new(ELeave) CDesCArrayFlat(KMissedAlarmListBoxItems);

    iMissedAlarmStore = iServices.MissedAlarmStore();

    // Get the missed alarms count

    iMissedAlarmStore->CountL(iMissedAlarmsCount);

    iListBox = new( ELeave ) CAknDoubleGraphicStyleListBox;

    iListBox->ConstructL( this, 0);

    iListBox->SetContainerWindowL( *this);

    // Create scroll bar

    iListBox->CreateScrollBarFrameL(ETrue);

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,

            CEikScrollBarFrame::EAuto);

    iListBox->SetListBoxObserver( this ); // single click changes MK

    // set the model array

    iListBox->Model()->SetItemTextArray(iListBoxItemArray);

    // set icon array

    CAknIconArray* iconArray = CreateIconsL( iIconIndices, KCalenMissedAlarmsViewUidValue ); 

    CleanupStack::PushL(iconArray);

    iListBox->ItemDrawer()->FormattedCellData()->SetIconArray(iconArray);

    CleanupStack::Pop();

    iListBox->Model()->SetOwnershipType(ELbmDoesNotOwnItemArray);

    iListBox->View()->SetListEmptyTextL( KNullDesC );

    iFirstTap = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::UpdateSize

// Do layout changes after calendar settings are

// changed.  No necessary actions for this view.

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

//

void CCalenMissedAlarmsContainer::UpdateSize()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::IconIndexForEntryL

// Gets the Icon Index for the missed alarm entry 

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

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

//

TInt CCalenMissedAlarmsContainer::IconIndexForEntryL(CCalEntry& aEntry, 

                                                    TInt aSeenMissedAlarm)

    {

    TRACE_ENTRY_POINT;

    TInt iconIndex(0);

    if(aSeenMissedAlarm)

        {

        switch(aEntry.EntryTypeL())

            {

            case CCalEntry::EAnniv:

                iconIndex = IconIndex(MCalenServices::ECalenBirthdayIcon);

                break;

            case CCalEntry::EEvent:

                iconIndex = IconIndex(MCalenServices::ECalenDaynoteIcon);

                break;

            case CCalEntry::EAppt:

                iconIndex = IconIndex(MCalenServices::ECalenMeetingIcon);

                break;

            case CCalEntry::ETodo:

                iconIndex = IconIndex(MCalenServices::ECalenTodoIconUndone);

                break;

            default:

                ASSERT( EFalse );

                break;

            }

        }

    else

        {

        switch(aEntry.EntryTypeL())

            {

            case CCalEntry::EAnniv:

                iconIndex = IconIndex(MCalenServices::ECalenBirthdayIconMissed);

                break;

            case CCalEntry::EEvent:

                iconIndex = IconIndex(MCalenServices::ECalenDaynoteIconMissed);

                break;

            case CCalEntry::EAppt:

                iconIndex = IconIndex(MCalenServices::ECalenMeetingIconMissed);

                break;

            case CCalEntry::ETodo:

                iconIndex = IconIndex(MCalenServices::ECalenToDoIconMissed);

                break;

            default:

                ASSERT( EFalse );

                break;

            }

        }

    return iconIndex;

    TRACE_EXIT_POINT;    

    }

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

// CCalenMissedAlarmsContainer::CreateIconIndicesL

// Fill the list of icons used by the MAV

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

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

//

void CCalenMissedAlarmsContainer::CreateIconIndicesL(

                               RArray<MCalenServices::TCalenIcons>& aIndexArray)

    {

    TRACE_ENTRY_POINT;

    aIndexArray.Reset();

    aIndexArray.AppendL( MCalenServices::ECalenBirthdayIcon );

    aIndexArray.AppendL( MCalenServices::ECalenDaynoteIcon );

    aIndexArray.AppendL( MCalenServices::ECalenMeetingIcon );

    aIndexArray.AppendL( MCalenServices::ECalenTodoIconUndone );

    aIndexArray.AppendL( MCalenServices::ECalenBirthdayIconMissed );

    aIndexArray.AppendL( MCalenServices::ECalenDaynoteIconMissed );

    aIndexArray.AppendL( MCalenServices::ECalenMeetingIconMissed );

    aIndexArray.AppendL( MCalenServices::ECalenToDoIconMissed );

    aIndexArray.AppendL( MCalenServices::ECalenClearMissedAlarms );

    aIndexArray.AppendL( MCalenServices::ECalenClearAllMissedAlarms )

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::GetHelpContext

// Get help context.

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

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

//

void CCalenMissedAlarmsContainer::GetHelpContext(TCoeHelpContext& aContext) const

    {

    TRACE_ENTRY_POINT;

    aContext.iMajor = KUidCalendar;

    aContext.iContext = KCALE_HLP_MONTH_VIEW; // need to change	

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::MopSupplyObject

// Pass the skin information

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

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

//

TTypeUid::Ptr CCalenMissedAlarmsContainer::MopSupplyObject(TTypeUid aId)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return MAknsControlContext::SupplyMopObject(aId, iBgContext);

    }

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

// CCalenMissedAlarmsContainer::ListBox

// Returns the listbox

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

//

CAknDoubleGraphicStyleListBox* CCalenMissedAlarmsContainer::ListBox() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iListBox;

    }

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

// CCalenMissedAlarmsContainer::SizeChanged

// Called by the framework when the view size is changed.

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

//

void CCalenMissedAlarmsContainer::SizeChanged()

    {

    TRACE_ENTRY_POINT;

    TRect main_pane( Rect() );

    CCalenContainer::SizeChanged( main_pane );

    if(iListBox)

        {

        iListBox->SetRect( main_pane );

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::CountComponentControls

// Gets the number of controls contained in a compound control.

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

//

TInt CCalenMissedAlarmsContainer::CountComponentControls() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return 1;

    }

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

// CCalenMissedAlarmsContainer::ComponentControl

// Gets the specified component of a compound control.

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

//

CCoeControl* CCalenMissedAlarmsContainer::ComponentControl(TInt aIndex) const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    switch (aIndex)

        {

        case 0:

            return iListBox;

        default:

            return NULL;

        }

    }

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

// CCalenMissedAlarmsContainer::OfferKeyEventL

// Called by the framework when a key event needs to be processed. 

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

//

TKeyResponse CCalenMissedAlarmsContainer::OfferKeyEventL(

        const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    TRACE_ENTRY_POINT;

    TKeyResponse ret(EKeyWasNotConsumed);

    if (EEventKey == aType)

        {

        switch (aKeyEvent.iCode)

            {

            case EKeyBackspace:

            case EKeyDelete:

                {

                iView->HandleCommandL(ECalenCmdClear);

                ret = EKeyWasConsumed;

                }

                break;

            default:

                break;

            }

        }

    if(ret == EKeyWasNotConsumed)

        {

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

        ret = iListBox->OfferKeyEventL(aKeyEvent, aType);

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

        if(oldCursor != newCursor)

            {

            iHighlightedRowNumber = newCursor;

            SetContextFromMissedAlarmEntryL(newCursor);

            }

        }

    TRACE_EXIT_POINT;

    return ret;

    }

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

// CCalenMissedAlarmsContainer::HandleResourceChange

// Handles a change to the application's resources which are shared across the environment. 

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

//

void CCalenMissedAlarmsContainer::HandleResourceChange(TInt aType)

    {

    TRACE_ENTRY_POINT;

    CCalenContainer::HandleResourceChange( aType );

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

        {

//        SizeChanged();

    TRect main_pane;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, main_pane );

    SetRect( main_pane );

    if(iListBox)

        {

        TRect mainPane;

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

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

        iListBox->SetRect( bgContextRect );

        }

        // refresh

        TRAPD(error,iView->BeginRepopulationL());

        if(error!=KErrNone)

            {

            // do avoid warning

            }         

        }

    CCoeControl::HandleResourceChange( aType );

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::Draw

// Draws the control

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

//

void CCalenMissedAlarmsContainer::Draw(const TRect& aRect) const

    {

    TRACE_ENTRY_POINT;

    CWindowGc& gc = SystemGc();

    TRect main_pane( Rect() );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

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

    AknsDrawUtils::Background(skin, cc, this, gc, aRect);

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::HandlePointerEventL

// Handles the pointer events in touch resolutions

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

//

void CCalenMissedAlarmsContainer::HandlePointerEventL(

        const TPointerEvent& aPointerEvent)

    {

    TRACE_ENTRY_POINT;

    TInt pointerIndex(-1);

    TBool isItem (iListBox->View()->XYPosToItemIndex(aPointerEvent.iPosition, pointerIndex));

    if(iView->IsCalenLaunchedFromExtApp())

        {

        return;

        }

    if(isItem == EFalse)

        {

        iListBox->HandlePointerEventL(aPointerEvent);

        return;

        }

    TInt index = iListBox->CurrentItemIndex();

    switch (aPointerEvent.iType)

        {

        case TPointerEvent::EButton1Down:

            {

            TBool isItem (iListBox->View()->XYPosToItemIndex(aPointerEvent.iPosition, pointerIndex));

            if(isItem && MissedAlarmsCount() > 0)

                {

                iHighlightedRowNumber = iListBox->View()->CurrentItemIndex(); 

                SetContextFromMissedAlarmEntryL(iListBox->View()->CurrentItemIndex());

                }

            break;

            }

        case TPointerEvent::EDrag:

            {

            /*iListBox->HandlePointerEventL(aPointerEvent);

            if (iFirstTap && index != iListBox->CurrentItemIndex())

                {

                iFirstTap = EFalse;

                }*/

            break;

            }

        case TPointerEvent::EButton1Up:

            {

           // if (iFirstTap)

                {

               // iView->HandleCommandL(ECalenMissedEventView);

                }

            break;

            }

        default:

            break;

        }

   if ( aPointerEvent.iType != TPointerEvent::EButtonRepeat )

        {

        iListBox->HandlePointerEventL( aPointerEvent );

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedAlarmsContainer::HandleNaviDecoratorEventL

// ?implementation_description

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

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

//

void CCalenMissedAlarmsContainer::HandleNaviDecoratorEventL( TInt /*aEventID*/ )

    {

    TRACE_ENTRY_POINT;