/*

* 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:   Missed Event View implementation

*

*/

// system includes

#include <StringLoader.h>

#include <aknbutton.h>

#include <akntoolbar.h>

#include <finditem.hrh>

#include <finditemmenu.h>

#include <Calendar.rsg>

#include <missedalarm.h>

#include <missedalarmstore.h>

#include <calenagendautils.h>

#include <calentry.h>

#include <calentryview.h>

#include <calencommands.hrh>            // Calendar commands

#include <calencontext.h>

#include <CalenStatusPaneUtils.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include <aknappui.h>

// user includes

#include "calenmissedeventview.h"

#include "calendarui_debug.h"

#include "calenmissedeventcontainer.h"

#include <calenview.h>

#include "CalenUid.h"

#include "calenentryutil.h"

#include "CleanupResetAndDestroy.h"

// Button position of the MSK CBA button

const TInt KSK2CBAPosition = 2;

_LIT8( KCommandMissedEventView,"MEV" );

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

// CCalenMissedEventView::NewL

// Two-phased constructor.

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

//

EXPORT_C CCalenMissedEventView* CCalenMissedEventView::NewL( MCalenServices& aServices )

	{

	TRACE_ENTRY_POINT;

	CCalenMissedEventView* self = new( ELeave )CCalenMissedEventView( aServices );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

	}

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

// CCalenMissedEventView::ConstructL

// Constructor

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

//

void CCalenMissedEventView::ConstructL()

	{

	TRACE_ENTRY_POINT;

	CommonConstructL( R_CALEN_MISSED_EVENT_VIEW );

	TRACE_EXIT_POINT;

	}

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

// CCalenMissedEventView::CCalenMissedEventView

// C++ constructor.

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

//

CCalenMissedEventView::CCalenMissedEventView( MCalenServices& aServices )

    : CCalenNativeView( aServices ),

    iPopulationStep( ENothingDone )

    {

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::~CCalenMissedEventView

// Destructor

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

//

CCalenMissedEventView::~CCalenMissedEventView()

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	}

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

// CCalenMissedEventView::ActiveStepL

// From CCalenView

// (other items were commented in a header)

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

//

CCalenView::TNextPopulationStep CCalenMissedEventView::ActiveStepL()

    {

    TRACE_ENTRY_POINT;

	CCalenView::TNextPopulationStep nextStep = CCalenView::EDone;

	CCalenMissedEventContainer* cnt = static_cast<CCalenMissedEventContainer*>( iContainer );

    switch( iPopulationStep )

        {

        case ENothingDone:

        	{

			iPopulationStep = EBuildTextEditor;

			nextStep = CCalenView::EKeepGoing;

        	}

        	break;

        case EBuildTextEditor:

        	{

        	cnt->BuildTextEditorL();

 			iPopulationStep = ERequestInstanceView;       	

 			nextStep = CCalenView::EKeepGoing;

        	}

        	break;

        case ERequestInstanceView:

        	{

        	cnt->RequestInstanceViewL();

			iPopulationStep = EAddField; 

 			nextStep = CCalenView::EKeepGoing;			       	

        	}

        	break;

        case EAddField:

        	{

        	cnt->AddFieldsL();

			iPopulationStep = EPopulationDone;   

 			nextStep = CCalenView::EKeepGoing;			     	

        	}

        	break;

        case EPopulationDone: 

        default:    

        	{

        	cnt->CompletePopulationL();

        	if(!iAvkonAppUi->IsDisplayingMenuOrDialog())

        	    {

                RedrawStatusPaneL();

        	    }

        	nextStep = CCalenView::EDone;

        	}

        	break;

        }

    TRACE_EXIT_POINT;  

    return nextStep;  

    }

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

// CCalenMissedEventView::CancelPopulation

// From CCalenView

// (other items were commented in a header)

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

//

void CCalenMissedEventView::CancelPopulation()

    {

    TRACE_ENTRY_POINT;

    iPopulationStep = ENothingDone;

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::LocalisedViewNameL

// From CCalenView

// (other items were commented in a header)

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

//

const TDesC& CCalenMissedEventView::LocalisedViewNameL( CCalenView::TViewName /*aViewName*/ )

    {

    TRACE_ENTRY_POINT;

    _LIT(KEV,"Missed Event View");

    TRACE_EXIT_POINT;

    return KEV;

    }

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

// CCalenMissedEventView::ViewIcon

// From CCalenView

// (other items were commented in a header)

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

//

CGulIcon* CCalenMissedEventView::ViewIconL() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return NULL;

    }

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

// CCalenMissedEventView::DoActivateImplL

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

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

//

void CCalenMissedEventView::DoActivateImplL( const TVwsViewId& aPrevViewId,

                                      TUid aCustomMessageId ,

                                      const TDesC8& aCustomMessage )

    {

    TRACE_ENTRY_POINT;

    iShowCloseButtonOnCba =

        ( aCustomMessageId == KUidCalenShowCloseCba ? ETrue : EFalse );

    // for handling missedeventview activation from sn/indicator

    // when only one missed alarm is there

    // issue command ECalenMissedEventViewFromIdle to set the context,

    // clear the missed alarm before launching missed event view

    if(aPrevViewId.iAppUid!=KUidCalendar)

        {

        // get the custom view message

        HBufC8* temp = aCustomMessage.AllocLC();

        TPtr8 des = temp->Des();

        des.UpperCase();

        if( des.Find( KCommandMissedEventView) != KErrNotFound )

            {

            iServices.IssueCommandL(ECalenMissedEventViewFromIdle);

            }

        CleanupStack::PopAndDestroy( temp );

        }

    UpdateCbaL();

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::DoDeactivateImpl

// Take action before deactivating the view

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

//

void CCalenMissedEventView::DoDeactivateImpl()

    {

    TRACE_ENTRY_POINT;

    iPreviousViewId.iViewUid = KNullUid;

    /*MCalenToolbar* toolbar = iServices.ToolbarOrNull(); 

    if(toolbar)

        {

        toolbar->SetToolbarVisibilityL(ETrue);  

        }*/

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::OnLocaleChangedL

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

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

//

void CCalenMissedEventView::OnLocaleChangedL(TInt /*aReason*/)  

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::RedrawStatusPaneL

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

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

//

void CCalenMissedEventView::RedrawStatusPaneL()  

    {

    TRACE_ENTRY_POINT;

    CCalenMissedEventContainer* cnt = static_cast<CCalenMissedEventContainer*>( iContainer );

    HBufC* titleText = StringLoader::LoadLC( cnt->GetTitleTextId(), iCoeEnv );

    iSPUtils->UnderLineTitleText( EFalse );

    iSPUtils->SetTitleText( titleText );    // ownership passed

    CleanupStack::Pop( titleText );

    iSPUtils->RefreshStatusPane();

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::HandleCommandL

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

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

//

void CCalenMissedEventView::HandleCommandL(TInt aCommand)  

    {

    TRACE_ENTRY_POINT;

    CCalenMissedEventContainer* cnt = static_cast<CCalenMissedEventContainer*>( iContainer );

	switch(aCommand)

		{

		case ECalenCmdPromptThenEdit:

			{

			iServices.IssueCommandL(ECalenEditCurrentEntry);

			break;	

			}

        case ECalenCompleteTodo:

        case ECalenRestoreTodo:            

        	{        

            CCalenNativeView::HandleCommandL(aCommand);         

        	}

            break;

        case EAknSoftkeyClose:

            {

            MCalenToolbar* toolbar = iServices.ToolbarOrNull(); 

            if(toolbar)

                {

                toolbar->SetToolbarVisibilityL(ETrue);  

                }

            iServices.IssueNotificationL(ECalenNotifyMissedEventViewClosed);

            break;

            }

        case EAknSoftkeyBack:

			{		

	        iServices.IssueNotificationL(ECalenNotifyMissedEventViewClosed);

			break;

			}

        case EAknSoftkeyExit: 

            {

            CCalenNativeView::HandleCommandL(aCommand);

            }

            break;

        case ECalenCmdFindPhoneNum:

            {

            cnt->OnCmdFindPhoneNumL();

             }

             break;

        case ECalenCmdFindEmail:

            {

            cnt->OnCmdFindEmailL();

            }

            break;

        case ECalenCmdFindURL:

            {

            cnt->OnCmdFindUrlL();

            }

        default:

            if(cnt->GetFindItemMenu()->CommandIsValidL(aCommand))

                {

                cnt->GetFindItemMenu()->HandleItemFinderCommandL(aCommand);

                return;

                }

            CCalenNativeView::HandleCommandL(aCommand);

            break;

        }

    TRACE_EXIT_POINT;

    }  

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

// CCalenMissedEventView::DynInitMenuPaneL

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

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

//

void CCalenMissedEventView::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)

	{

    TRACE_ENTRY_POINT;

    CCalenMissedEventContainer* cnt = static_cast<CCalenMissedEventContainer*>( iContainer );

    switch(aResourceId)

    	{

	    case R_CALEN_EVENT_VIEW_MENUPANE:

        case R_CALEN_EVENT_VIEW_LONGTAP_MENUPANE:

	    	{

	    	CCalenEntryUtil* eventViewData = cnt->GetEventViewData();

            if(eventViewData)

                {

                if(eventViewData->EntryType() == CCalEntry::ETodo)

                      {

                      if(eventViewData->Status() == CCalEntry::ETodoCompleted)

                          {

                          aMenuPane->DeleteMenuItem(ECalenCompleteTodo);

                          }

                      else

                          {

                          aMenuPane->DeleteMenuItem(ECalenRestoreTodo);

                          }

                      }             

                  else

                      {

                      aMenuPane->DeleteMenuItem(ECalenCompleteTodo);

                      aMenuPane->DeleteMenuItem(ECalenRestoreTodo);

                      }

                }

		  	 if(CCalenLocationUtil::IsMapProviderAvailableL())

            	{

	            if(cnt->IsEventHasMapLocationL() || cnt->IsEventHasNoLocationTextL())

		            {

		            aMenuPane->DeleteMenuItem( ECalenGetLocationAndReplace );

		            }

		        if(!cnt->IsEventHasMapLocationL())

			        {

			        aMenuPane->DeleteMenuItem( ECalenShowLocation );	

			        }	

            	}

            else // No map provider available, remove both option items

	            {

	            aMenuPane->DeleteMenuItem( ECalenGetLocationAndReplace );

	            aMenuPane->DeleteMenuItem( ECalenShowLocation );	

	            }

			//as no toolbar in missedeventview no need to handle thees commands

		  	aMenuPane->DeleteMenuItem( ECalenCmdPromptThenEdit );

		  	aMenuPane->DeleteMenuItem( ECalenDeleteCurrentEntry ); 

		  	aMenuPane->DeleteMenuItem( ECalenSend );

		    break;

		  	}

		 default:

		    {

		      cnt->GetFindItemMenu()->UpdateItemFinderMenuL(aResourceId,aMenuPane); 

		    }

			break;

		}

    TRACE_EXIT_POINT;	

	}

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

// CCalenMissedEventView::Id

// Returns unique view id

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

//

TUid CCalenMissedEventView::Id() const

	{

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;	

    return KUidCalenMissedEventView;

	}

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

// CCalenMissedEventView::CreateContainerImplL

// create container

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

//

CCalenContainer* CCalenMissedEventView::CreateContainerImplL() 

	{

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;	

    return new( ELeave )CCalenMissedEventContainer( this, iServices );

	}

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

// CCalenMissedEventView::UpdateCbaL

// Set CBA button 

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

//

void CCalenMissedEventView::UpdateCbaL()

    {

    TRACE_ENTRY_POINT;  

    CEikButtonGroupContainer*  cba = Cba();

    if(iShowCloseButtonOnCba)

        {

        cba->SetCommandL( KSK2CBAPosition, R_CALEN_CLOSE_CBA_BUTTON );

        }

    else

        {

        cba->SetCommandL( KSK2CBAPosition, R_CALEN_BACK_CBA_BUTTON);

        }

    cba->DrawNow();

    TRACE_EXIT_POINT;

    }

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

// CCalenMissedEventView::ClearViewSpecificDataL

// Clear view specific data

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

//

void CCalenMissedEventView::ClearViewSpecificDataL()

	{

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;	

	}

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

// CCalenMissedEventView::CyclePosition

// Returns view cycle position

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

//

CCalenView::TCyclePosition CCalenMissedEventView::CyclePosition() const

	{

	TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;	

    return ENoCyclePosition;

	}

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

// CCalenMissedEventView::AddToolbarButtonsL

// Adds the necessary toolbar buttons on the existing toolbar for event viewer

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

//

void CCalenMissedEventView::AddToolbarButtonsL()

	{

	TRACE_ENTRY_POINT;

	// Get the existing toolbar from MCalenservices

	MCalenToolbar* toolbarImpl = iServices.ToolbarOrNull();

	if(toolbarImpl)  // If toolbar exists

		{