/*
* Copyright (c) 2007 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:  Implementation of UI utils
*
*/


#include <calencommonui.rsg>
#include <Calendar.rsg>
#include <calenagendautils.h>
#include <aknlists.h>
#include <aknnotewrappers.h>
#include <AknQueryDialog.h>
#include <AknUtils.h>
#include <calalarm.h>
#include <calentry.h>
#include <calentryview.h>
#include <ErrorUI.h>
#include <StringLoader.h>
#include <sysutil.h>
#include <calentry.h>
#include <calinstance.h>
#include <calinstanceview.h>
#include <calencommands.hrh>            // Calendar commands
#include <calendateutils.h>
#include <caleninstanceid.h>            // TCalenInstanceId
#include <calenactionuiutils.h>

#include "calendarui_debug.h"           // Debug
#include "calendar.hrh"
#include "calenicons.h"
#include "calenglobaldata.h"
#include "CalenInterimUtils2.h"
#include "CleanupResetAndDestroy.h"

// Constants
const TInt KArrayGranularity = 5;

// ----------------------------------------------------------------------------
// CalenActionUiUtils::ShowDeleteConfirmationQueryL
// Shows a delete confirmation query.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CalenActionUiUtils::ShowDeleteConfirmationQueryL( 
        const TDeleteConfirmationType aType, 
        const TInt aCount )
    {
    TRACE_ENTRY_POINT;

    CAknQueryDialog* dialog = CAknQueryDialog::NewL();
    CleanupStack::PushL( dialog );

    TInt resID( 0 );

    switch( aType )
        {
        case EDeleteEntry:
            resID = R_CALEN_COMMONUI_QTN_CALE_QUEST_DELETE_EVENT;
            break;
        case EDeleteToDo:
            resID = R_CALEN_COMMONUI_QTN_TODO_QUEST_DELETE_NOTE;
            break;
        case EDeleteToDos:
            resID = R_CALEN_COMMONUI_QTN_TODO_QUEST_DELETE_NOTES;
            break;
        case EDeleteAll:
            resID = R_CALEN_COMMONUI_QTN_CALE_QUEST_DELETE_ALL_NOTES;
            break;
        default:
            User::Leave( KErrArgument );
            break;
        }

    HBufC* prompt;

    // if >1 event to be deleted, load multi-deletion confirmation string
    if( aCount > 1 )
        {
        prompt = StringLoader::LoadLC( resID, aCount );
        }
    // otherwise load common deletion confirmation string
    else
        {
        prompt = StringLoader::LoadLC( resID );
        }

    dialog->SetPromptL( *prompt );
    CleanupStack::PopAndDestroy( prompt );

    CleanupStack::Pop( dialog );

    TRACE_EXIT_POINT;
    return dialog->ExecuteLD( R_CALEN_COMMONUI_ERASEQUERY_NOTE );
    }

// ----------------------------------------------------------------------------
// CalenActionUiUtils::ShowRepeatTypeQueryL
// Shows a query asking the user to choose the repeat type.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CalenActionUiUtils::ShowRepeatTypeQueryL( 
        CalCommon::TRecurrenceRange& aAnswer, 
        const TRepeatQueryType aType )
    {
    TRACE_ENTRY_POINT;

    CAknSinglePopupMenuStyleListBox* list;
    list = new( ELeave ) CAknSinglePopupMenuStyleListBox;
    CleanupStack::PushL( list );
    
    CAknPopupList* popupList;
    popupList = CAknPopupList::NewL( list, R_AVKON_SOFTKEYS_OK_CANCEL );
    CleanupStack::PushL( popupList );

    list->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );
    list->CreateScrollBarFrameL(ETrue);
    list->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
                                                                  CEikScrollBarFrame::EAuto );
    CEikonEnv* eikEnv = CEikonEnv::Static();

    CDesCArrayFlat* items = eikEnv->ReadDesCArrayResourceL( aType == EEdit ?
                                R_CALEN_COMMONUI_REPEATNOTE_EDIT_CHOICELIST :
                                R_CALEN_COMMONUI_REPEATNOTE_CHOICELIST );
    CTextListBoxModel* model = list->Model();
    model->SetItemTextArray( items );

    TInt resID( 0 );

    switch( aType )
        {
       case ESave:
           resID = R_CALEN_COMMONUI_QTN_CALE_LQ_SAVE_CHANG_REPEATED;
           break;
        case EDelete:
            resID = R_CALEN_COMMONUI_QTN_CALE_LQ_DEL_REPEATED_NOTE;
            break;
        case EEdit:
            resID = R_CALEN_COMMONUI_QTN_CALE_LQ_EDIT_RECURRING;
            break;
        default:
            User::Leave( KErrArgument );
            break;
        }

    HBufC* title = StringLoader::LoadLC( resID, eikEnv );
    popupList->SetTitleL( *title );
    CleanupStack::PopAndDestroy( title );

    TBool ret( ETrue );

    if( popupList->ExecuteLD() )
        {
        const TInt selected( list->CurrentItemIndex() );

        switch( selected )
            {
            case ECalenRepeatThis:
                aAnswer = CalCommon::EThisOnly;
                break;
            case ECalenRepeatThisFuture:
                aAnswer = CalCommon::EThisAndFuture;
                break;
            case ECalenRepeatThisPast:
                aAnswer = CalCommon::EThisAndPrior;
                break;
            case ECalenRepeatAll:
                aAnswer = CalCommon::EThisAndAll;
                break;
            default:
                ASSERT( EFalse );
                break;
            }
        }
    else
        {
        ret = EFalse;
        }

    CleanupStack::Pop( popupList );
    CleanupStack::PopAndDestroy( list );

    TRACE_EXIT_POINT;
    return ret;
    }

// ----------------------------------------------------------------------------
// CalenActionUiUtils::DateQueryL
// Prompts the user for a time. Requires a title resource id, or pass 0
// for default title "Date:".
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CalenActionUiUtils::DateQueryL( TTime& aDate, TInt aPromptId )
    {
    TRACE_ENTRY_POINT;

    if ( aPromptId == 0 )
        {
        aPromptId = R_CALEN_DATE_PROMPT;
        }

    CAknTimeQueryDialog* dlg = CAknTimeQueryDialog::NewL( aDate,
                                                          CAknQueryDialog::ENoTone );
    CleanupStack::PushL( dlg );

    HBufC* prompt = StringLoader::LoadLC( aPromptId, CEikonEnv::Static() );
    dlg->SetPromptL( *prompt );
    CleanupStack::PopAndDestroy( prompt );

    CleanupStack::Pop(); // dlg

    TRACE_EXIT_POINT;
    return dlg->ExecuteLD( R_CALEN_DAYQUERY_NOTE );
    }

// ----------------------------------------------------------------------------
// CalenActionUiUtils::SetToDoCompleteStatusL
// Mark to-do entry as completed or restore a completed to-do and save.
// This is not in the engine layer because it shows an error mesage on failure.
// (other items were commented in a header).
// ----------------------------------------------------------------------------
//
EXPORT_C void CalenActionUiUtils::SetToDoCompleteStatusL( 
        CCalEntryView& aEntryView, 
        CCalEntry* aEntry, 
        const TBool aStatus )
    {
    TRACE_ENTRY_POINT;

    ASSERT( aEntry );
    TTime now;
    now.HomeTime();
    TCalTime caltime;
    caltime.SetTimeLocalL( now );

    // set as completed or restore
    aEntry->SetCompletedL( aStatus, caltime );

    // Save the to-do
    TInt error( 0 );
    CEikonEnv* eikenv = CEikonEnv::Static();

    // Check disk space of C drive.
    const TInt writesize( 512 ); // Write size

    if( SysUtil::FFSSpaceBelowCriticalLevelL( &( eikenv->FsSession() ), writesize ) )
        {
        CErrorUI* errorui = CErrorUI::NewLC();
        errorui->ShowGlobalErrorNoteL( KErrDiskFull );
        CleanupStack::PopAndDestroy();
        TRACE_EXIT_POINT;
        return;
        }

    RPointerArray<CCalEntry> list;
    CleanupClosePushL( list );

    TInt entrynum;

    // update entry
    list.Append( aEntry );
    TRAP( error, aEntryView.UpdateL( list, entrynum ) );

    if( error == KErrNotFound )
        {
        // entry was deleted...?
        list.Reset();
        list.Append( aEntry );
        TRAP( error, aEntryView.StoreL( list, entrynum ) );
        }
    CleanupStack::PopAndDestroy( &list );
    User::LeaveIfError( error );

    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CCalenCommonUI::PrepareLbDataForNewNotesQueryL
// Prepares ListBox items for NewEntry query
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CalenActionUiUtils::PrepareLbDataForNewNotesQueryL( 
        CDesCArrayFlat*& aListItems, 
        CArrayFixFlat<TInt>*& aListItemCommands )
    {
    TRACE_ENTRY_POINT;

    if( ( aListItems == NULL ) && ( aListItemCommands == NULL) )
        {
        // List items for list query.
        aListItems = new( ELeave ) CDesCArrayFlat( KArrayGranularity );

        // This array is used to map user selection to correct service.
        aListItemCommands = new( ELeave ) CArrayFixFlat<TInt>( KArrayGranularity );

        // Add the item strings to listItems
        // Add the item commands to listItemCommands
        // Consider also meeting request item
        HBufC* temp = NULL;

        temp = CCoeEnv::Static()->AllocReadResourceLC( R_CALEN_NEW_MEETING_NOTE );
        aListItems->AppendL( *temp );
        CleanupStack::PopAndDestroy( temp );
        temp = NULL;
        aListItemCommands->AppendL( ECalenNewMeeting );
        
        // Check with interim utils if the Meeting request viewers are enabled.
        CCalenInterimUtils2* interimUtils = CCalenInterimUtils2::NewL();
        CleanupStack::PushL( interimUtils );
        if( interimUtils->MRViewersEnabledL() )
            {
            temp = CCoeEnv::Static()->AllocReadResourceLC( R_CALEN_NEW_MEETING_REQUEST_NOTE );
            aListItems->AppendL( *temp );
            CleanupStack::PopAndDestroy( temp );
            temp = NULL;
            aListItemCommands->AppendL( ECalenNewMeetingRequest );
            }
        CleanupStack::PopAndDestroy( interimUtils );
        
        temp = CCoeEnv::Static()->AllocReadResourceLC( R_CALEN_DAY_NOTE );
        aListItems->AppendL(*temp );
        CleanupStack::PopAndDestroy( temp );
        temp = NULL;
        aListItemCommands->AppendL( ECalenNewDayNote );

        temp = CCoeEnv::Static()->AllocReadResourceLC( R_CALEN_NOTE_ANNIVERSARY );
        aListItems->AppendL(*temp);
        CleanupStack::PopAndDestroy( temp );
        temp = NULL;
        aListItemCommands->AppendL( ECalenNewAnniv );

        temp = CCoeEnv::Static()->AllocReadResourceLC( R_CALEN_NOTE_TODO );
        aListItems->AppendL(*temp );
        CleanupStack::PopAndDestroy( temp );
        temp = NULL;
        aListItemCommands->AppendL( ECalenNewTodo );
        }

    TRACE_EXIT_POINT;
    }

// -----------------------------------------------------------------------------
// CCalenCommonUI::ShowNewNoteQueryL
// Shows the list query for NewEntry
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CalenActionUiUtils::ShowNewNoteQueryL( 
        CDesCArrayFlat*& aListItems, 
        CArrayFixFlat<TInt>*& aListItemCommands )
    {
    TRACE_ENTRY_POINT;

    PrepareLbDataForNewNotesQueryL( aListItems, aListItemCommands );

    // Show list query.
    TInt choice = KErrCancel; //KErrNotFound;
    CAknListQueryDialog* dlg = new( ELeave ) CAknListQueryDialog( &choice );
    dlg->PrepareLC( R_CALENDAR_NEW_NOTE_QUERY ); // pushes dlg to CS
    dlg->SetItemTextArray( aListItems );
    dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Set title
    CAknPopupHeadingPane* heading = dlg->Heading();
    HBufC* title = NULL;
    title = CCoeEnv::Static()->AllocReadResourceLC( 
                                            R_CALENDAR_NEW_NOTE_QUERY_TITLE );
    heading->SetTextL( *title );
    CleanupStack::PopAndDestroy( title );

    if( dlg->RunLD() )
        {
        // user made a choice
        choice = aListItemCommands->At( choice );
        }

    TRACE_EXIT_POINT;
    return choice;
    }

// -----------------------------------------------------------------------------
// CCalenCommonUI::FindPossibleInstanceL
// Finds an instance with the given instance id and instance view.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CCalInstance* CalenActionUiUtils::FindPossibleInstanceL( 
        const TCalenInstanceId& aId,
        CCalInstanceView& aInstanceView )
    {
    TRACE_ENTRY_POINT;

    RPointerArray<CCalInstance> instances;
    CleanupResetAndDestroyPushL( instances );

    TCalTime moment;
    moment.SetTimeLocalL( aId.iInstanceTime );
    CalCommon::TCalTimeRange range( moment, moment );
    aInstanceView.FindInstanceL( instances, CalCommon::EIncludeAll, range );

    CCalInstance* result = NULL;

    // For instances finishing the next day (now possible with unified DateTime editor),
    // we have to do our best to match the instance time exactly - otherwise we could
    // match the LocalUid to the incorrect instance in a series.
    for ( TInt i=0; i < instances.Count() && !result; ++i )
        {
        if( instances[i]->Entry().LocalUidL() == aId.iEntryLocalUid )
            {
            // Check the instance time matches.
            if( instances[i]->StartTimeL().TimeLocalL() == aId.iInstanceTime )
                {
                result = instances[i];
                instances.Remove(i);
                }
            }
        }

    if( !result )
        {
        // Couldn't match the instance time exactly - just use the instance
        // with the same LocalUid as the one we're looking for.
        for ( TInt i=0; i < instances.Count() && !result; ++i )
            {
            if( instances[i]->Entry().LocalUidL() == aId.iEntryLocalUid )
                {
                result = instances[i];
                instances.Remove(i);
                }
            }
        }

    CleanupStack::PopAndDestroy( &instances );

    TRACE_EXIT_POINT;
    return result;
    }

// End of file