/*

* Copyright (c) 2002-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:  CCalenTodoView is derived from CCalenNativeView.

*

*/

#include <calenagendautils.h>

#include <calsession.h>

#include <calinstance.h>

#include <StringLoader.h>

#include <centralrepository.h>

#include <hlplch.h>

#include <eikclb.h>

#include <eikmenup.h>

#include <sendui.h>

#include <featmgr.h>

#include <aknbutton.h>

#include <akntoolbar.h>

#include <Calendar.rsg>

#include <calencommonui.rsg>

#include <Sendnorm.rsg>

#include <calencontext.h>

#include <CalenStatusPaneUtils.h>

#include <aknnotewrappers.h>

#include <calenservices.h>

#include <caleninstanceid.h>

#include <calenviewutils.h>

#include "calendarui_debug.h"

#include "calentodoview.h"

#include "CalendarPrivateCRKeys.h"  

#include "calencontroller.h"

#include "calensend.h"

#include "calentitlepane.h"

#include "calentodocontroller.h"

#include "calentodocontainer.h"

#include "CalenInterimUtils2.h"

#include "CalenUid.h"

#include "CalenUid.h"

#include "calendar.hrh"

#include "multicaluidialog.h"

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

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

// CCalenTodoView::NewL

// Two-phased constructor.

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

//

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

    {

    TRACE_ENTRY_POINT;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenTodoView::ConstructL

// Constructor

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

//

void CCalenTodoView::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iCountOfSelectedItems = -1;

    CommonConstructL( R_TODO_LISTVIEW );

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::CCalenTodoView

// C++ constructor.

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

//

CCalenTodoView::CCalenTodoView( MCalenServices& aServices )

    : CCalenNativeView( aServices ),

      iPopulationStep( ENothingDone )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::~CCalenTodoView

// Destructor

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

//

CCalenTodoView::~CCalenTodoView()

    {

    TRACE_ENTRY_POINT;

    delete iIdle;

    if( iCmdCallback )

        {

        delete iCmdCallback;

        }

    iMarkedInstances.Reset();

    iMarkedInstances.Close();

    if(iMarkedTodoItems)

        {

        delete iMarkedTodoItems;

        iMarkedTodoItems = NULL;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::OnCmdDeleteEntryL

// Handling command "Delete"

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

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

//

void CCalenTodoView::OnCmdDeleteEntryL(void)

    {

    TRACE_ENTRY_POINT;

    const TInt count( Container()->Controller()->Count() );

    const TInt markCount( Container()->MarkedCount() );

    if( markCount > 0 )

        {

        CreateMultiplecontextForMarkedItemsL(ECalenDeleteEntryWithoutQuery);

        }

    else

        {

        // Delete the current item.

        iServices.IssueCommandL( ECalenDeleteCurrentEntry );

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::OnLocaleChangedL

// This function is called when Locale or Today was changed.

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

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

//

void CCalenTodoView::OnLocaleChangedL(TInt aReason)  // Notify reson EChangesLocale | EChangesMidnightCrossover

    {

    TRACE_ENTRY_POINT;

    if (!iContainer)

        {

        return;

        }

    // FIXME...See examples from day, week and month views

    // JH although this does the refresh it might not be even needed as we don't have any UI

    // elements(?) that change after local change.

    if (IsContainerFocused())

        {

        if (!iContainer->IsFocused())

            {

            iLocChangeReason = EChangesLocale;

            }

        else

            {

            if (aReason & EChangesLocale)

                {

                BeginRepopulationL();

                }

            else

                {

                RedrawStatusPaneL();

                }

            }

        }

    else

        {

        iLocChangeReason = EChangesLocale;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::ItemCount

// Return number of item.

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

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

//

TInt CCalenTodoView::ItemCount()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return Container()->Controller()->Count();

    }

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

// CCalenTodoView::CurrentItemIsCrossOutL

// Check cross out of current item.

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

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

//

TBool CCalenTodoView::CurrentItemIsCrossOutL()

    {

    TRACE_ENTRY_POINT;

    TBool status( EFalse );

    TInt index( Container()->CurrentItemIndex() );

    if( index >= 0 )

        {

        status = Container()->Controller()->IsCrossOutL( index );

        }

    TRACE_EXIT_POINT;

    return status;

    }

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

// CCalenTodoView::SaveCurrentItemIndexL

// Save the index of current item.

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

//

void CCalenTodoView::SaveCurrentItemIndexL()

    {

    TRACE_ENTRY_POINT;

    TInt index = Container()->CurrentItemIndex();

    CCalInstance* instance = Container()->Controller()->InstanceL( index );

    if( index >= 0 && instance )

        {

        TCalenInstanceId id = TCalenInstanceId::CreateL( *instance );

        iServices.Context().SetInstanceIdL( id,

                                      TVwsViewId( KUidCalendar, KUidCalenTodoView ) );

        iFirstEntryOnScreenIndex = Container()->ListBox()->TopItemIndex();

        iHighlightedRowNumber = Container()->ListBox()->CurrentItemIndex();

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::Container

// Return the container pointer.

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

//

CCalenTodoContainer* CCalenTodoView::Container()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return static_cast<CCalenTodoContainer*>( iContainer );

    }

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

// CCalenTodoView::HandleCommandL

// Command handling for each view

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

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

//

void CCalenTodoView::HandleCommandL( TInt aCommand ) // command ID

    {

    TRACE_ENTRY_POINT;

    switch( aCommand )

        {

        // Handle MSK command Open

        case ECalenViewCurrentEntry:

        case EAknSoftkeyOpen:

            SaveCurrentItemIndexL();

           if(!Container()->IsEmptyView() && !iEventViewCommandHandled)

               {

               if(!Container()->MarkedCount())

                   {

                   CCalenNativeView::HandleCommandL(ECalenEventView);

                   iEventViewCommandHandled = ETrue;

                   break;

                   }

               else

                   {

                   CListBoxView* listboxview = Container()->ListBox()->View();

                   TInt index = Container()->CurrentItemIndex();

                   TBool iselected=listboxview->ItemIsSelected(index);

                   if( !Container()->Controller()->Count() || iselected )

                   	{

                    	 // display the context sensitive menu

                     	/* CEikMenuBar* menuBar = MenuBar();

                    	 menuBar->SetContextMenuTitleResourceId( R_TODO_LIST_SELECTION_CONTEXT_MENUBAR );

                    	 menuBar->TryDisplayContextMenuBarL();

                    	 */

                    	 }

               	   else

                    	 {

                    	 CCalenNativeView::HandleCommandL( ECalenEventView );

                    	 }

                   }

               }

            break;

        //TODO: will be uncommented with copy to cal functionality.   

        case ECalenCopyToCalendars:

            {

            SaveCurrentItemIndexL();

            CopyToCalendarsL();

            }

            break;

#ifdef RD_CALEN_ENHANCED_MSK            

        case ECalenCmdOpenMskDialog:

        	CCalenNativeView::HandleCommandL( ECalenNewMeeting );

        	break;

#else

        case EAknSoftkeyContextOptions:

            MenuBar()->TryDisplayContextMenuBarL();

            break;

#endif //RD_CALEN_ENHANCED_MSK

        case ECalenDeleteCurrentEntry:

            {

            SaveCurrentItemIndexL();

            if( Container()->MarkedCount() >= 1 )

                {

                // delete marked entries

                OnCmdDeleteEntryL();

                }

            else

                {

                SaveCurrentItemIndexL();

                CCalenNativeView::HandleCommandL( aCommand );

                }

            }

            break;

        case ECalenMarkOne:

            SaveCurrentItemIndexL();

            Container()->MarkCurrentL( ETrue );

            break;

        case ECalenUnmarkOne:

            SaveCurrentItemIndexL();

            Container()->MarkCurrentL( EFalse );

            break;

        case ECalenMarkAll:

            SaveCurrentItemIndexL();

            Container()->MarkAllL( ETrue );

            break;

        case ECalenUnmarkAll:

            SaveCurrentItemIndexL();

            Container()->MarkAllL( EFalse );

            break;

        case ECalenMarkDone:

            SaveCurrentItemIndexL();

            CreateMultiplecontextForMarkedItemsL(ECalenMarkDone);

            break;

        case ECalenMarkUnDone:

            SaveCurrentItemIndexL();

            CreateMultiplecontextForMarkedItemsL(ECalenMarkUnDone);

            break;

        // These differ from native view because all new entries from the

        // todo view start today. However this does mean that if the user

        // discards changes to the new entry, we are returned to the top of

        // the list as the context is today. Can't see an easy way round it.

        case ECalenNewMeeting:

        case ECalenNewMeetingRequest:

        case ECalenNewAnniv:

        case ECalenNewDayNote:

        case ECalenNewTodo:

            {

            // set the editoractive for not showing the preview popup or preview pane

            SetEditorActive(ETrue);

            MCalenContext& context = iServices.Context();

            // Set the date on the context to today. It will set it to be the

            // default of view (8am) on that day as we don't specify the time.

            TTime homeTime;

            homeTime.HomeTime();

            TCalTime today;

            today.SetTimeLocalL( homeTime );

            context.SetFocusDateL( today,

                                   TVwsViewId( KUidCalendar, Id() ) );

            iServices.IssueCommandL( aCommand );

            break;

            }

        case ECalenDayView:

        case ECalenWeekView:

        case ECalenMonthView:

            {

            SaveCurrentItemIndexL();

            // clear marked to do items before launching the native views 

            if(iMarkedTodoItems)

                {

                ClearMarkedToDoItems();

                }

            iServices.IssueCommandL( aCommand );

            }

            break;

        case ECalenShowCalendars:            

			SaveCurrentItemIndexL();

            Container()->MarkAllL( EFalse ); 

			CCalenNativeView::HandleCommandL( aCommand );

			break;

        default:

            SaveCurrentItemIndexL();

            CCalenNativeView::HandleCommandL( aCommand );

            break;

        }

    UpdateCBAButtonsL();

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::DeleteMarkedNotesL

// Delete marked notes.

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

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

//

void CCalenTodoView::DeleteMarkedNotesL()

    {

    TRACE_ENTRY_POINT;

    CEikColumnListBox* listbox = Container()->ListBox();

    const CListBoxView::CSelectionIndexArray& selectedItems = *(listbox->SelectionIndexes());

    TInt markCount( selectedItems.Count() );

    ASSERT( markCount );

    iCountOfSelectedItems = markCount;  // Save count of marked item

    CCalenTodoController* controller = Container()->Controller();

    iMarkedInstances.Reset();

    for( TInt i(0); i < markCount; ++i )

        {

        TInt indexPos( selectedItems[i] );

        iMarkedInstances.AppendL( controller->InstanceL( indexPos ) );

        }

	SetMultipleContexts();

    // Find index of the item to be focused after deletion.

    FindFocusAfterDeletionL( selectedItems );

    iServices.IssueCommandL( ECalenDeleteEntryWithoutQuery );

    TRACE_EXIT_POINT;

    }

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

// CCalenTodoView::FindFocusAfterDeletionL

// Save new current postion of item after deleting marked items.

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

//

void CCalenTodoView::FindFocusAfterDeletionL(const CListBoxView::CSelectionIndexArray& aSelectedItems)

    {

    TRACE_ENTRY_POINT;

    // calculate the item position after deleting marked items.

    TInt index( Container()->CurrentItemIndex() );

    TInt indexpos( 0 );

    TInt adjustitems( 0 );

    TBool markedAndFocus( EFalse );

    iItemIndexAfterDeletion = 0;    // Initialize item position

    for( TInt n(0); n < iCountOfSelectedItems; n++ )

        {

        indexpos = (aSelectedItems)[n];

        if( indexpos <= index )

            {

            ++adjustitems;

            }

        if( indexpos == index )

            {

            markedAndFocus = ETrue;  // Focused item is marked.

            }

        }

    // (Selection Service Spec 10.0 section 1.2.2.)

    indexpos = index -adjustitems; // Adjust postion

    // Current item is marked and focused.

    if( markedAndFocus )

        {

        TInt prevcount( Container()->Controller()->Count() );

        if( indexpos < (prevcount -iCountOfSelectedItems -1) )

            {

            // Focused item is not last.

            // Focus goes to the next item.

            ++indexpos;

            }

        }

    // Save new item position after deleting.

    iItemIndexAfterDeletion = indexpos;