/*

* Copyright (c) 2005 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 for meeting request info popup 

*

*/

// INCLUDE FILES

#include "CMRInfoPopup.h"

#include "MRViewersPanic.h"

#include "MREntryConsultant.h"

#include "CMRStringFormatter.h"

#include <meetingrequestviewersuires.rsg>

#include <CMRMailboxUtils.h>

#include <calentry.h> 		//CCalEntry (Calendar entry API V2)

#include <caluser.h> 		//caluser and attendee

#include <AknInfoPopupNoteController.h>

#include <stringloader.h>

#include <eikenv.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

_LIT( KPanicMsg, "CMRInfoPopup" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

// Avkon takes milliseconds as a parameter, but timers use microseconds,

// therefore to must avoid overflow the maximum time is KMaxInt / 1000.

const TInt KMaxMilliseconds = KMaxTInt / 1000;

const TInt KBufferSize = 512;

}  // namespace

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

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

// CMRInfoPopup::NewL

// Two-phased constructor.

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

//

CMRInfoPopup* CMRInfoPopup::NewL(

    CEikonEnv* aEnv,

    CMRMailboxUtils& aMBoxUtils,

    const CCalEntry& aEntry,

    TBool aViewMode )

    {

    CMRInfoPopup* self =

        new( ELeave ) CMRInfoPopup( aEnv, aMBoxUtils, aViewMode );

    CleanupStack::PushL( self );

    self->ConstructL( aEntry );

    CleanupStack::Pop();

    return self;

    }

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

// CMRInfoPopup::CMRInfoPopup

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMRInfoPopup::CMRInfoPopup(

     CEikonEnv* aEnv,

     CMRMailboxUtils& aMBoxUtils,

     TBool aViewMode )

    : iEnv( aEnv ),

      iMBoxUtils( aMBoxUtils ),

      iViewMode( aViewMode ), 

      iIsValid( ETrue ),

      iIsSent( EFalse ),

      iRowIndex( 0 )

    {

    }

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

// CMRInfoPopup::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMRInfoPopup::ConstructL( const CCalEntry& aEntry )

    {

    iBuffer.CreateL( KBufferSize );

    iStringFormatter = CMRStringFormatter::NewL( *iEnv );

    iNoteController = CAknInfoPopupNoteController::NewL();

    // no delay:

    iNoteController->SetTimeDelayBeforeShow( 0 );

    // according to spec info popup is shown all the time in MR Viewers,

    // when we give KMaxMilliseconds it will be shown for ~35 hours:

    iNoteController->SetTimePopupInView( KMaxMilliseconds );

    RefreshTextL( aEntry, 0 ); // row index 0 used at startup    

    }

// Destructor

CMRInfoPopup::~CMRInfoPopup()

    {

    delete iStringFormatter;

    delete iNoteController;

    iBuffer.Close();

    }

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

// CMRInfoPopup::ShowInfoPopupL

// 

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

//

void CMRInfoPopup::ShowInfoPopupL()

    {

    iNoteController->ShowInfoPopupNote();

    }

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

// CMRInfoPopup::HideInfoPopup

// 

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

//

void CMRInfoPopup::HideInfoPopup()

    {

    iNoteController->HideInfoPopupNote();

    }

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

// CMRInfoPopup::SetMeetingValidity

// 

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

//        

void CMRInfoPopup::SetMeetingValidity( TBool aIsValid )

    {

    iIsValid = aIsValid;

    }

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

// CMRInfoPopup::SetSendingStatus

// 

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

//        

void CMRInfoPopup::SetSendingStatus( TBool aIsSent )

    {

    iIsSent = aIsSent;

    }

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

// CMRInfoPopup::RefreshTextL

// 

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

//        

void CMRInfoPopup::RefreshTextL( const CCalEntry& aEntry, TInt aRowIndex )

    {

    __ASSERT_DEBUG( aRowIndex == 0 || aRowIndex == 1,

                    Panic( EIllegalParamValue ) );

    iRowIndex = aRowIndex;

    // update data in iBuffer and in note controller, info popup may be

    // currently visible or not

    if ( iRowIndex == 0 )

        {

        FillWithMeetingInfoL( aEntry );

        }

    else

        {

        if ( iViewMode )

            {            

            FillWithViewerAttendeeInfoL( aEntry );

            }

        else

            {

            FillWithEditorAttendeeInfoL( aEntry );

            }

        }        

    iNoteController->SetTextL( TextL() );

    ShowInfoPopupL();

    }

const TDesC& CMRInfoPopup::TextL()

    {

    return iBuffer;

    }

void CMRInfoPopup::FillWithMeetingInfoL( const CCalEntry& aEntry )

    {

    iBuffer.Zero();

    if ( MREntryConsultant::IsRepeatingMeetingL( aEntry ) )

        {

        StringLoader::Load( iBuffer, R_QTN_CALE_INFOPOPUP_RECURRING, iEnv );

        iBuffer.Append( EKeyLineFeed );

        }

    HBufC* timeString( NULL );     

// TODO: check day span this when UI spec is corrected

//        if ( MREntryConsultant::SpansManyDaysL( aEntry.StartTimeL(),

//                                                aEntry.EndTimeL() ) )

    timeString = iStringFormatter->WhenStringLC( aEntry.StartTimeL(),

                                                 aEntry.EndTimeL() );

    iBuffer.Append( *timeString );

    CleanupStack::PopAndDestroy( timeString );

    }

void CMRInfoPopup::FillWithViewerAttendeeInfoL( const CCalEntry& aEntry )

    {

    iBuffer.Zero();

    TInt resource( 0 );    

    CCalAttendee* thisAtt = iMBoxUtils.ThisAttendeeL( aEntry );        

    if ( aEntry.StatusL() == CCalEntry::ECancelled )

        {

        resource = R_QTN_CALE_STATUS_CANCELLED;

        }

    else if ( MREntryConsultant::IsEntryOutOfDateL( aEntry ) ||

              !iIsValid )

        {

        resource = R_QTN_CALE_STATUS_OUT_OF_DATE;

        }

    else if ( thisAtt )

        {

        switch ( thisAtt->StatusL() )

            {

            case CCalAttendee::ENeedsAction:

                {

                resource = R_QTN_CALE_STATUS_PLEASE_RESPOND;

                break;

                }

            case CCalAttendee::EAccepted: // fall through

            case CCalAttendee::EConfirmed:

                {

                resource = R_QTN_CALE_STATUS_ACCEPTED;

                break;

                }                    

            case CCalAttendee::ETentative:

                {

                resource = R_QTN_CALE_STATUS_TENTATIVE;

                break;

                } 

            case CCalAttendee::EDeclined:

                {

                resource = R_QTN_CALE_STATUS_DECLINED;

                break;

                }

            default:

                {

                break;

                }                    

            }

        }

    if ( resource != 0 )

        {                

        StringLoader::Load( iBuffer, resource, iEnv );

        }

    }

void CMRInfoPopup::FillWithEditorAttendeeInfoL( const CCalEntry& aEntry )

    {

    iBuffer.Zero();

    if ( iIsSent )

        {

        RPointerArray<CCalAttendee>& attendees = aEntry.AttendeesL();

        TInt count( attendees.Count() );

        TInt countAccepted( 0 );

        TInt countTentative( 0 );        

        TInt countDeclined( 0 );

        TInt countNeedsAction( 0 );

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

            {

            switch ( attendees[i]->StatusL() )

                {

                case CCalAttendee::EAccepted: // fall through

                case CCalAttendee::EConfirmed:

                    {

                    countAccepted++;

                    break;

                    }                    

                case CCalAttendee::ETentative:

                    {

                    countTentative++;

                    break;

                    } 

                case CCalAttendee::EDeclined:

                    {

                    countDeclined++;

                    break;

                    }

                case CCalAttendee::ENeedsAction:

                    {

                    countNeedsAction++;

                    break;

                    }                    

                default:

                    {

                    break;

                    }                    

                }

            }

        if ( countAccepted > 0 )

            {

            HBufC* accepts = StringLoader::LoadLC(

                R_QTN_CALE_INFOPOPUP_ACCEPTED, countAccepted, iEnv );

            iBuffer.Append( *accepts );

            CleanupStack::PopAndDestroy( accepts );

            iBuffer.Append( EKeyLineFeed );            

            }

        if ( countDeclined > 0 )

            {

            HBufC* declines = StringLoader::LoadLC(

                R_QTN_CALE_INFOPOPUP_DECLINED, countDeclined, iEnv );

            iBuffer.Append( *declines );

            CleanupStack::PopAndDestroy( declines );

            iBuffer.Append( EKeyLineFeed );

            }

        if ( countTentative > 0 )

            {

            HBufC* tentatives = StringLoader::LoadLC(

                R_QTN_CALE_INFOPOPUP_TENTATIVE, countTentative, iEnv );

            iBuffer.Append( *tentatives );

            CleanupStack::PopAndDestroy( tentatives );

            iBuffer.Append( EKeyLineFeed );

            }

        if ( countNeedsAction > 0 )

            {

            HBufC* noresponses = StringLoader::LoadLC(

                R_QTN_CALE_INFOPOPUP_NO_RESPONSE, countNeedsAction, iEnv );

            iBuffer.Append( *noresponses );

            CleanupStack::PopAndDestroy( noresponses );

            iBuffer.Append( EKeyLineFeed );

            }                                    

        }

    else

        {

        StringLoader::Load( iBuffer, R_QTN_CALE_INFOPOPUP_NOT_SENT, iEnv );

        }

    }

//  End of File