/*

* Copyright (c) 2008-2009 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:  View class for Events Management UI.

*

*/

// SYSTEM INCLUDES

#include <evtmgmtui.rsg>

#include <hlplch.h>

#include <featmgr.h>

#include <eikmenup.h>

#include <eikbtgpc.h>

#include <StringLoader.h>

#include <aknmessagequerydialog.h>

#include <aknnotewrappers.h> 

#include <eikserverapp.h>

#include <textresolver.h>

#include <csxhelp/loc.hlp.hrh>

// USER INCLUDES

#include "evtmgmtuiuid.hrh"

#include "evtmgmtuistartupview.h"

#include "evtmgmtuistartupcontainer.h"

#include "evtmgmtuiappui.h"

#include "evtmgmtui.hrh"

#include "evteventsdlg.h"

#include "evtdebug.h"

#include "evtmgmtuilocsettinglauncher.h"

#include "evtmgmtuimodel.h"

#include "evtmgmtuilbtadapter.h"

#include "evtmgmtuimapnavigationadapter.h"

// CONSTANT DEFINTIONS

const TUid	KEvtMgmtUiStartupViewId = TUid::Uid( 1 );

const TInt KMaxEvents = 50;

_LIT( KWaitCycleError, "Wait Cycle Error" );

// ----------------- Member funtions for CEvtMgmtUiStartupView class -----------------------

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

// CEvtMgmtUiStartupView::CEvtMgmtUiStartupView

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

//  

CEvtMgmtUiStartupView::CEvtMgmtUiStartupView()

    {

    }

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

// CEvtMgmtUiStartupView::~CEvtMgmtUiStartupView

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

//  

CEvtMgmtUiStartupView::~CEvtMgmtUiStartupView()

    {

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

    	delete iContainer; 

        }

    // Unregister the command handler as an observer

    if( iEngine )

	{

	iEngine->RemoveObserver( this );

       	delete iEngine;

	}

    delete iPosSetLauncher;

    if(iEvtIdArray)

        {

        iEvtIdArray->Close();

        delete iEvtIdArray;

        }

    delete iModel;

    FeatureManager::UnInitializeLib();

    }

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

// CEvtMgmtUiStartupView* CEvtMgmtUiStartupView::NewL

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

//        

CEvtMgmtUiStartupView* CEvtMgmtUiStartupView::NewL()

    {

    CEvtMgmtUiStartupView* self = new ( ELeave ) CEvtMgmtUiStartupView();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// void CEvtMgmtUiStartupView::ConstructL

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

//  

void CEvtMgmtUiStartupView::ConstructL()

    {

    if(iEikonEnv->StartedAsServerApp())

        {

        iIsEmbeddedApp = ETrue;

        BaseConstructL( R_EVTMGMTUI_STARTUP_VIEW_EMBEDDED );

        }

    else

        {

        iIsEmbeddedApp = EFalse;

        BaseConstructL( R_EVTMGMTUI_STARTUP_VIEW );

        }

    // Create Log Directory.

    //CREATELOGDIR();

    // Feature manager required for Help feature check

    FeatureManager::InitializeLibL();

    iEngine = CEvtMgmtUiEngine::NewL();    

    iEngine->SetObserver(this);  

    iEngine->SyncDbsL();

    iModel = CEvtMgmtUiModel::NewL();

    iEngine->UpdateModelL(iModel->EventsArray(), CEvtMgmtUiEngine::EEvtFilterAll ); 

    iModel->SetStatusFilter( CEvtMgmtUiEngine::EEvtFilterAll );  

    iModel->UpdateEventsStatus( );

    }

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

// void CEvtMgmtUiStartupView::DoActivateL

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

//  	

void CEvtMgmtUiStartupView::DoActivateL( const TVwsViewId&  /* PrevViewId*/,

                                             TUid           /* aCustomMessageId*/,

                                       const TDesC8&        /* aCustomMessage */)

    {

    // Destroy the existing container if it exists

    if( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

        iContainer=NULL;

        }                       

    // Create new Container 

    iContainer = CEvtMgmtUiStartupContainer::NewL( ClientRect(), iModel, *this);

    iContainer->SetMopParent( this );

    AppUi()->AddToViewStackL( *this, iContainer );   	   

    if(iModel->TotalEvents())

        MenuBar()->SetMenuTitleResourceId ( R_EVTMGMTUI_STARTUP_MENUBAR_MARK );

    else

        MenuBar()->SetMenuTitleResourceId ( R_EVTMGMTUI_STARTUP_MENUBAR );

    }

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

// void CEvtMgmtUiStartupView::DoDeactivate

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

//           

void CEvtMgmtUiStartupView::DoDeactivate()

    {

    // Destroy Container

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

        iContainer = NULL;

        }

    }

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

// TUid CEvtMgmtUiStartupView::Id

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

//   

TUid CEvtMgmtUiStartupView::Id() const

    {

    return KEvtMgmtUiStartupViewId;

    }

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

//  CEvtMgmtUiStartupView::HandleShowOnMapCommandL

//  It will handle 'show on map' command.

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

//

void CEvtMgmtUiStartupView::HandleShowOnMapCommandL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiStartupView::HandleShowOnMapCommandL()" );

    CEvtMgmtUiMapNavigationAdapter* map = CEvtMgmtUiMapNavigationAdapter::NewL();

    CleanupStack::PushL(map);

    TCoordinate loc;

    iEngine->RetrieveLocationL( iModel->EventId( iContainer->CurrentItemIndex() ), loc );        

    map->ShowOnMapL( loc );

    CleanupStack::PopAndDestroy(); //map

    EVTUIDEBUG("- CEvtMgmtUiStartupView::HandleShowOnMapCommandL()" );

    }

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

//  CEvtMgmtUiStartupView::HandleNavigateToPlaceCommandL

//  It will handle 'navigate to place' command.

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

//

void CEvtMgmtUiStartupView::HandleNavigateToPlaceCommandL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiStartupView::HandleNavigateToPlaceCommandL()" );

    CEvtMgmtUiMapNavigationAdapter* map = CEvtMgmtUiMapNavigationAdapter::NewL();

    CleanupStack::PushL(map);    

    TCoordinate loc;

    iEngine->RetrieveLocationL( iModel->EventId( iContainer->CurrentItemIndex() ), loc );

    map->NavigateToPlaceL( loc );

    CleanupStack::PopAndDestroy(); //map

    EVTUIDEBUG("- CEvtMgmtUiStartupView::HandleNavigateToPlaceCommandL()" );

    }

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

// void CEvtMgmtUiStartupView::HandleCommandL

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

//       

void CEvtMgmtUiStartupView::HandleCommandL( TInt aCommand )   

    {

    EVTUIDEBUG1("+ CEvtMgmtUiStartupView::HandleCommandL = %d", aCommand);

    TInt currentItemIndex= iContainer->CurrentItemIndex();

    // This class only handles the commands specific to this view

    switch( aCommand )

    	{

    	case EEvtMgmtUiStartupViewOpen:

			{			

			if(currentItemIndex>0)

				{ 

                TCoeHelpContext context;

                context.iContext = KHLP_LOC_EVENTS_EDITOR();

                context.iMajor = TUid::Uid( KEvtMgmtUiUid );	

				CEvtEvent* evt = iEngine->EventL( EventIdOfCurrentItem() );	

				CleanupStack::PushL( evt );

				CEvtEventsDlg* form = CEvtEventsDlg::NewL(EFalse, *evt, *iEngine);  

				form->SetHelpContext( context );            

				form->ExecuteLD( ); 	

				CleanupStack::PopAndDestroy( evt );

				iContainer->MakeTitleL();

				}           

			break;

			} 

    	case EEvtMgmtUiStartupViewCreate:

			{

			currentItemIndex = KErrNotFound;

			if(iModel->TotalEvents() < KMaxEvents )

			    {

                TCoeHelpContext context;

                context.iContext = KHLP_LOC_EVENTS_EDITOR();

                context.iMajor = TUid::Uid( KEvtMgmtUiUid );	

				CEvtEvent* evt = iEngine->EventL( 0 );	

				CleanupStack::PushL( evt );

			    CEvtEventsDlg* form = CEvtEventsDlg::NewL(ETrue, *evt, *iEngine );                

				form->SetHelpContext( context );            

			    form->ExecuteLD( );

				CleanupStack::PopAndDestroy( evt );

				iContainer->MakeTitleL();

				if(iModel->TotalEvents())

			        MenuBar()->SetMenuTitleResourceId ( R_EVTMGMTUI_STARTUP_MENUBAR_MARK );

			    else

			        MenuBar()->SetMenuTitleResourceId ( R_EVTMGMTUI_STARTUP_MENUBAR );

			    }

			else

			    {

			    HBufC* errMsg = StringLoader::LoadLC( R_EVTUI_MAXEVENTS_ERROR, iCoeEnv );

                CAknInformationNote* errNote = new(ELeave) CAknInformationNote();

                errNote->ExecuteLD( *errMsg );

                CleanupStack::PopAndDestroy(errMsg);   

			    }

			break;

			}   

    	case EEvtEditorCmdDelete:

    	    {

    	    TInt cnt = iContainer->NumberOfMarkedItems();

    	    if( currentItemIndex != 0 || cnt )

    	        {

                HBufC* msg = NULL;

                if(cnt>1)

                    msg = StringLoader::LoadLC(R_LOCEV_CONFIRM_MULTIDELETE_EVENT, cnt, CEikonEnv::Static() );

                else

                    msg = StringLoader::LoadLC(R_LOCEV_CONFIRM_DELETE_EVENT, CEikonEnv::Static() );

                //if not deleted, do nothing

               if(DisplayConfirmationQueryDlgL(*msg))

                   { 	         

                    iWaitState = EWaitDlgLaunchToDelete;   

                    StartWaitDialogL();

                   }

                CleanupStack::PopAndDestroy(msg);

    	        }

            break;

            }   	

    	case EEvtEditorCmdShowAll:

    		{

    		iModel->SetCurrentItemId( iContainer->CurrentItemIndex() );

    		iModel->SetStatusFilter( CEvtMgmtUiEngine::EEvtFilterAll );

    		UpdateViewL(); 

    		break;

    		}

    	case EEvtEditorCmdShowDrafts:

    		{    		

    		iModel->SetCurrentItemId( iContainer->CurrentItemIndex() );

    		iModel->SetStatusFilter( CEvtMgmtUiEngine::EEvtFilterDraft );

    		UpdateViewL(); 

    		break;

    		}

    	case EEvtEditorCmdShowActive:

    		{ 

    		iModel->SetCurrentItemId( iContainer->CurrentItemIndex() );

    		iModel->SetStatusFilter( CEvtMgmtUiEngine::EEvtFilterActive );

    		UpdateViewL(); 

    		break;

    		}

        case EEvtEditorCmdShowCompleted:

            {           

            iModel->SetCurrentItemId( iContainer->CurrentItemIndex() );

            iModel->SetStatusFilter( CEvtMgmtUiEngine::EEvtFilterCompleted );

            UpdateViewL(); 

            break;

            }

    	case EEvtEditorCmdActivate:

    	    {    	    

    	    iEvtStatus = EActive;

    	    iWaitState = EWaitDlgLaunchToChangeStatus;   

    	    StartWaitDialogL();    	        	    

    	    break;

    	    }

	   case EEvtEditorCmdSaveDraft:

            {

            iEvtStatus = EDraft;  

            iWaitState = EWaitDlgLaunchToChangeStatus;   

            StartWaitDialogL();                    

            break;

            }

	   case EAknCmdMark:

	   case EAknSoftkeyMark:

	       {

	       if(currentItemIndex != KErrNotFound)

	           {

	           iContainer->HandleMarkCmdL(currentItemIndex, ETrue);

	           HandleCmdL( EListBoxItemFocused );

	           }

	       break;

	       }

	   case EAknCmdUnmark:

	   case EAknSoftkeyUnmark:

	       {

	       if(currentItemIndex != KErrNotFound)

	           {

    	       iContainer->HandleMarkCmdL(currentItemIndex, EFalse);

    	       HandleCmdL( EListBoxItemFocused );

	           }

	       break;

	       }

	   case EAknMarkAll:

	       {

	       iContainer->HandleMarkCmdL(KErrNotFound, ETrue);

	       HandleCmdL( EListBoxItemFocused );

	       break;

	       }

	   case EAknUnmarkAll:

	        {	                   

	        iContainer->HandleMarkCmdL(KErrNotFound, EFalse);

	        HandleCmdL( EListBoxItemFocused );

	        }

		    break;  

	   case EEvtEditorCmdNavigateToPlace:

	       {

	       HandleNavigateToPlaceCommandL();

	       break;

	       }

	   case EEvtEditorCmdShowOnMap:

	       {

	       HandleShowOnMapCommandL();

	       break;

	       }

	   case EEvtMgmtUiEventUiPosSettings:

	       {

	       if(!iPosSetLauncher)

               {

               iPosSetLauncher = CEvtMgmtUiLocSettingsLauncher::NewL();                

               }

	       iPosSetLauncher->LaunchL();

           break;

	       }

    	case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(),

                                                 AppUi()->AppHelpContextL());

            break;  

            }

        default:

        	{

			AppUi()->HandleCommandL( aCommand );

			break;        	

        	}

    	}

    EVTUIDEBUG("- CEvtMgmtUiStartupView::HandleCommandL");

    }

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

// void CEvtMgmtUiStartupView::ChangeEventStatus

// Change status of the event

// param[in] aStatus -  value to which event status should be changed

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

//  

void CEvtMgmtUiStartupView::ChangeEventStatusL( TEvtEventStatus aStatus )

    {      

    TInt cnt = iContainer->NumberOfMarkedItems();

    TInt index;

    if(iEvtIdArray)

        iEvtIdArray->Reset();

    else

        iEvtIdArray = new(ELeave) RArray<TEvtEventId>();

    if(cnt)

          {

          iDisplayNote = EFalse;

          EVTUIDEBUG1("CEvtMgmtUiStartupView::ChangeEventStatusL() selected items = %d", cnt );  

          const CArrayFix<TInt>* evtarray = iContainer->MarkItems();          

          TInt itemIndex = 0;             

          for(index=0;index<cnt;index++)

              {        

              itemIndex = iContainer->FilteredIndex((*evtarray)[index]);

              EVTUIDEBUG1("CEvtMgmtUiStartupView::ChangeEventStatusL() listboxindexid = %d", itemIndex);          

              EVTUIDEBUG1("Changing status of event Event id = %u", EventId(itemIndex) );

              //retrieve event details from model

              CEvtBasicEventInfo& event = iModel->EventFromModel(itemIndex);

              if( aStatus == EActive )

                 {               

                 //if manadatory fields are empty, display info note

                 if( event.Subject().Compare(KNullDesC)==0 || event.Place().Compare(KNullDesC)==0 )

                     {                    

                     iDisplayNote  = ETrue;

                     }

                 else

                     {

                     //if event is not having state to which it is supposed to change 

                     // then add it to id-list

                     if( event.EventStatus() !=  aStatus )

                         iEvtIdArray->Append( event.EventId() );

                     }

                  }  

              else

                  {

                  //if event is not having state to which it is supposed to change 

                  // then add it to id-list

                  if( event.EventStatus() !=  aStatus )

                      iEvtIdArray->Append( event.EventId() );

                  }

              }

          if(iEvtIdArray->Count())

              {

              iEngine->SetEventsStateL( aStatus, iEvtIdArray );

              }

          else

              {

              iWaitState = EWaitDlgDestroy;

              }

          HandleCommandL(EAknUnmarkAll);

          }

     else

          {

           TInt currentItemIndex = iContainer->CurrentItemIndex();

           if(aStatus == EActive)

                {

                if( iModel->EventFromModel(currentItemIndex).Subject().Compare(KNullDesC)==0 || 

					iModel->EventFromModel(currentItemIndex).Place().Compare(KNullDesC)==0 )

                    {                   

                    HBufC* warningMsg = StringLoader::LoadLC( R_EVTUI_MANDATORYFIELDS_WARNING, iCoeEnv );

                    CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL(*warningMsg);

                    dlg->PrepareLC(R_EVTUI_MESSAGE_QUERY);

                    dlg->RunLD();

                    CleanupStack::PopAndDestroy(warningMsg);

                    return;

                    }

                } 

           iEvtIdArray->Append( EventId( currentItemIndex ) ); 

           iEngine->SetEventsStateL(aStatus, iEvtIdArray  );

          }

    }

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

// void CEvtMgmtUiStartupView::ShowEvents

// Show all events with given status

// param[in] aStatusFilter - status filter to display events

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

//

void CEvtMgmtUiStartupView::ShowEventsL( CEvtMgmtUiEngine::TEvtEventStatusFilter aStatusFilter )

    {

	iModel->SetCurrentItemId( iContainer->CurrentItemIndex() );

	iModel->SetStatusFilter( aStatusFilter );

    UpdateViewL();

    }

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

// void CEvtMgmtUiStartupView::EnableMapFunctionalityL

// Check wether map functionality can be disabled.

// ret ETrue if map functionality should be enabled else EFalse

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

//

TBool CEvtMgmtUiStartupView::EnableMapFunctionalityL( )

    {

    EVTUIDEBUG("+ CEvtMgmtUiStartupView::DisableMapFunctionality()" );

    CEvtMgmtUiMapNavigationAdapter* map = CEvtMgmtUiMapNavigationAdapter::NewL();

    CleanupStack::PushL(map);

    //if no map service provider

    if ( map->MapServiceProvidersL() == 0 ) 

        {

        CleanupStack::PopAndDestroy(); //map

        EVTUIDEBUG("- CEvtMgmtUiStartupView::DisableMapFunctionality() EFalse" );

        return EFalse;

        }

    //Retrieve coordinate info

    TCoordinate loc;

    iEngine->RetrieveLocationL( iModel->EventId( iContainer->CurrentItemIndex() ), loc );        

    CleanupStack::PopAndDestroy(); //map