/*
* Copyright (c) 2007-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:  ESMR All day event checkbox field implementation
 *
*/

#include "emailtrace.h"
#include "cesmrcheckbox.h"

#include <eiklabel.h>
#include <AknIconUtils.h>
#include <fbs.h>
#include <eikimage.h>
#include <StringLoader.h>
#include <avkon.hrh>
#include <AknUtils.h>
#include <AknsUtils.h>
#include <data_caging_path_literals.hrh>

#include <esmrgui.rsg>
#include "cesmrborderlayer.h"
#include "mesmrlistobserver.h"
#include "mesmrmeetingrequestentry.h"
#include "mesmrfieldvalidator.h"
#include "esmrconfig.hrh"
#include "cesmriconfield.h"
#include "esmrhelper.h"
#include "cesmrlayoutmgr.h"

using namespace ESMRLayout;

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

// ---------------------------------------------------------------------------
// CESMRCheckbox::NewL
// ---------------------------------------------------------------------------
//
CESMRCheckBox* CESMRCheckBox::NewL( MESMRFieldValidator* aValidator )
    {
    FUNC_LOG;
    CESMRCheckBox* self = new (ELeave) CESMRCheckBox( aValidator );
    CleanupStack::PushL ( self );
    self->ConstructL ( );
    CleanupStack::Pop ( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::~CESMRCheckbox
// ---------------------------------------------------------------------------
//
CESMRCheckBox::~CESMRCheckBox( )
    {
    FUNC_LOG;
    delete iIcon;
    delete iBitmap;
    delete iBitmapMask;
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::SetOutlineFocusL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::SetOutlineFocusL( TBool aFocus )
    {
    FUNC_LOG;
    CESMRField::SetOutlineFocusL ( aFocus );

    //Focus gained
    if ( aFocus )
        {
        SwitchMSKLabelL();
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::ExecuteGenericCommandL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::ExecuteGenericCommandL( TInt aCommand )
    {
    FUNC_LOG;
    if(aCommand == EESMRCmdCheckEvent)
        {
        HandleCheckEventL();
        SwitchMSKLabelL();
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CESMRCheckBox::OfferKeyEventL(const TKeyEvent& aEvent,
        TEventCode aType )
    {
    FUNC_LOG;
    TKeyResponse response( EKeyWasNotConsumed);
    if ( aType == EEventKey )
        {
        if ( aEvent.iScanCode == EStdKeyDevice3 )
            {
            HandleCheckEventL ( );
            SwitchMSKLabelL();
            response = EKeyWasConsumed;
            }
        }
    return response;
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::CountComponentControls
// ---------------------------------------------------------------------------
//
TInt CESMRCheckBox::CountComponentControls( ) const
    {
    FUNC_LOG;
    TInt count = CESMRField::CountComponentControls ( );
    if ( iIcon )
        {
        ++count;
        }
    return count;
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::ComponentControl
// ---------------------------------------------------------------------------
//
CCoeControl* CESMRCheckBox::ComponentControl( TInt aInd ) const
    {
    FUNC_LOG;
    if ( aInd == 0 )
        {
        return iIcon;
        }
    return CESMRField::ComponentControl ( aInd );
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::SizeChanged
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::SizeChanged( )
    {
    FUNC_LOG;
    TRect rect = Rect ( );

    TInt iconTopMargin = ( rect.Height() - KIconSize.iHeight ) / 2;

    TPoint iconPos( rect.iTl.iX + KIconSize.iWidth + KIconBorderMargin,
                    rect.iTl.iY + iconTopMargin );


    TPoint borderPos( iconPos.iX + KIconSize.iWidth + KIconBorderMargin,
                      rect.iTl.iY);

    TSize borderSize( rect.Width() -
                      (2 * KIconSize.iWidth + 2 * KIconBorderMargin ),
                      rect.Height ( ));

    if ( CESMRLayoutManager::IsMirrored ( ) )
        {
        iconPos.iX = rect.iBr.iX - ( 2 * KIconSize.iWidth );
        borderPos.iX = iconPos.iX - borderSize.iWidth - KIconBorderMargin;
        }

    if ( iIcon )
        {
        iIcon->SetPosition ( iconPos );
        iIcon->SetSize ( KIconSize );
        }

    if ( iBorder )
        {
        iBorder->SetPosition ( borderPos );
        iBorder->SetSize ( borderSize );
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::InitializeL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::InitializeL()
    {
    FUNC_LOG;
    iLabel->SetFont( iLayout->Font( iCoeEnv, iFieldId ) );
    AknLayoutUtils::OverrideControlColorL(
            *iLabel,
            EColorLabelText,
            iLayout->GeneralListAreaTextColor() );
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::InternalizeL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::InternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    TBool alldayEvent( aEntry.IsAllDayEventL() );

    // Update the validator
    iValidator->SetAllDayEventL(  alldayEvent );

    // if this is all day event and not checked
    if ( alldayEvent && !iChecked )
        {
        HandleCheckEventL();
        }
    SetIconL( iChecked );
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::ExternalizeL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::ExternalizeL( MESMRCalEntry& /*aEntry*/)
    {
    FUNC_LOG;
    iValidator->SetAllDayEventL( iChecked );
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::SetIconL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::SetIconL( TBool aChecked )
    {
    FUNC_LOG;
    delete iIcon;
    iIcon = NULL;
    delete iBitmap;
    iBitmap = NULL;
    delete iBitmapMask;
    iBitmapMask = NULL;

    TAknsItemID iconID;
    TInt fileIndex(KErrNotFound);
    TInt fileMaskIndex(KErrNotFound);

    if( aChecked )
        {
        iconID = KAknsIIDQgnMeetReqIndiCheckboxMark;
        }
    else
        {
        iconID = KAknsIIDQgnMeetReqIndiCheckboxUnmark;
        }

    CESMRLayoutManager::SetBitmapFallback( iconID, fileIndex, fileMaskIndex );

    TFileName bitmapFilePath;
    ESMRHelper::LocateResourceFile(
            KESMRMifFile,
            KDC_APP_BITMAP_DIR,
            bitmapFilePath);

    TRAPD( err, AknsUtils::CreateIconL( AknsUtils::SkinInstance(),
                            iconID,
                            iBitmap,
                            iBitmapMask,
                            bitmapFilePath,
                            fileIndex,
                            fileMaskIndex
                            ) );

    if (err == KErrNotFound)
        {
        User::Leave(KErrNotFound);
        }

    // Even if creating mask failed, bitmap can be used (background is just not displayed correctly)
    if( iBitmap )
        {
        AknIconUtils::SetSize( iBitmap, KIconSize, EAspectRatioPreserved );
        iIcon = new (ELeave) CEikImage;
        iIcon->SetPictureOwnedExternally(ETrue);
        iIcon->SetPicture( iBitmap, iBitmapMask );
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::HandleCheckEventL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::HandleCheckEventL( )
    {
    FUNC_LOG;
    /*
     * Change check status
     */
    iChecked = !iChecked; // change status
    SetIconL ( iChecked ); // set icon for the status

    // update validator status:
    iValidator->SetAllDayEventL ( iChecked );

    /*
     * Add / remove new fields to list
     */
    if ( iChecked )
        {
        // start - end time should be removed
        // relateive alarm should be removed
        iObserver->RemoveControl ( EESMRFieldMeetingTime );
        iObserver->RemoveControl ( EESMRFieldAlarm );
        // absolute alarm should be inserted
        iObserver->InsertControl ( EESMRFieldAlarmOnOff );
        }
    else
        {
        iObserver->InsertControl ( EESMRFieldMeetingTime );
        iObserver->InsertControl ( EESMRFieldAlarm );
        iObserver->RemoveControl ( EESMRFieldAlarmOnOff );
        iObserver->RemoveControl ( EESMRFieldAlarmTime );
        iObserver->RemoveControl ( EESMRFieldAlarmDate );
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::SwitchMSKLabelL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::SwitchMSKLabelL()
    {
    FUNC_LOG;
    if(iChecked)
        {
        ChangeMiddleSoftKeyL(EESMRCmdCheckEvent, R_QTN_MSK_UNMARK);
        }
    else
        {
        ChangeMiddleSoftKeyL(EESMRCmdCheckEvent, R_QTN_MSK_MARK);
        }
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::CESMRCheckbox
// ---------------------------------------------------------------------------
//
CESMRCheckBox::CESMRCheckBox( MESMRFieldValidator* aValidator ) :
    iValidator( aValidator), iChecked( EFalse)
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRCheckbox::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRCheckBox::ConstructL( )
    {
    FUNC_LOG;
    SetFieldId( EESMRFieldAllDayEvent );
    iLabel = new (ELeave) CEikLabel;
    iLabel->SetLabelAlignment( CESMRLayoutManager::IsMirrored()
                               ? ELayoutAlignRight : ELayoutAlignLeft );

    HBufC* txt = StringLoader::LoadLC ( R_QTN_MEET_REQ_ALL_DAY_EVENT );
    iLabel->SetTextL( *txt );
    CleanupStack::PopAndDestroy( txt );

    iIcon = new (ELeave) CEikImage;

    CESMRField::ConstructL( iLabel );
    }

// EOF