/*
* Copyright (c) 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 alarm on off field implementation
*
*/

#include "emailtrace.h"
#include "cmralarmonofffield.h"
#include "cmrlabel.h"
#include "cmrimage.h"
#include "mesmrcalentry.h"
#include "mesmrlistobserver.h"
#include "mesmrfieldvalidator.h"
#include "nmrlayoutmanager.h"

#include <stringloader.h>
#include <avkon.hrh>
#include <esmrgui.rsg>
#include <aknutils.h>


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

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

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::CMRAlarmOnOffField
// ---------------------------------------------------------------------------
//
CMRAlarmOnOffField::CMRAlarmOnOffField() 
    {
    FUNC_LOG;
    iStatus = ETrue;
    
    SetFieldId ( EESMRFieldAlarmOnOff );
    SetFocusType ( EESMRHighlightFocus );
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::ConstructL
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::ConstructL( MESMRFieldValidator* aValidator )
    {
    FUNC_LOG;
    iValidator = aValidator;
    iValidator->SetAbsoluteAlarmOnOffFieldL( *this );
        
    iIcon = CMRImage::NewL( NMRBitmapManager::EMRBitmapAlarm );
    iIcon->SetParent( this );
    
    iLabel = CMRLabel::NewL();
    CESMRField::ConstructL( iLabel ); // ownership transfered
    iLabel->SetTextL( KNullDesC() );
    iLabel->SetParent( this );
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::~CMRAlarmOnOffField
// ---------------------------------------------------------------------------
//
CMRAlarmOnOffField::~CMRAlarmOnOffField( )
    {
    FUNC_LOG;
    delete iIcon;
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::InternalizeL
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::InternalizeL( MESMRCalEntry& aEntry )
    {
    FUNC_LOG;
    if ( aEntry.IsStoredL() ) // entry is already stored in db
        {
        MESMRCalEntry::TESMRAlarmType alarmType;
        TTime alarmTime;
        aEntry.GetAlarmL( alarmType, alarmTime );

        switch( alarmType )
            {
            //flow through
            case MESMRCalEntry::EESMRAlarmAbsolute:
            case MESMRCalEntry::EESMRAlarmRelative: // Show alarm as - ON
                {
                iStatus = ETrue;
                }
                break;
                //flow through
            case MESMRCalEntry::EESMRAlarmNotFound:
            default: // Show alarm as - OFF
                {
                iStatus = EFalse;
                }
                break;
            }
        }
    else // This is a new entry and default implementation is required
        {
        switch( aEntry.Type() )
            {
            case MESMRCalEntry::EESMRCalEntryTodo: // To-do
                {
                TTime alarmTime;
                MESMRCalEntry::TESMRAlarmType alarmType;
                aEntry.GetAlarmL (alarmType, alarmTime );

                // Change status to "ON" if alarm has been set by default
                iStatus = alarmType != MESMRCalEntry::EESMRAlarmNotFound;
                }
                break;
            // Flow through
            case MESMRCalEntry::EESMRCalEntryMeetingRequest: // Meeting request
            case MESMRCalEntry::EESMRCalEntryMeeting: // Meeting
                {
                iStatus = ETrue;// Change the status to "ON" for these dialog default
                }
                break;
                
            case MESMRCalEntry::EESMRCalEntryAnniversary: // Anniversary    
                {
                iStatus = ETrue;// Change the status to "ON" for these dialog default
                }
                break;
                // Flow through
            case MESMRCalEntry::EESMRCalEntryMemo: // Memo
            case MESMRCalEntry::EESMRCalEntryReminder: // Reminder
            
            default:
                iStatus = EFalse; // Change the status to "OFF" for these dialog default
                break;
            }
        }
    ResetFieldL();
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CMRAlarmOnOffField::OfferKeyEventL( const TKeyEvent& aEvent,
        TEventCode aType )
    {
    FUNC_LOG;
    TKeyResponse response( EKeyWasNotConsumed );
    if ( aType == EEventKey )
        {
        switch( aEvent.iScanCode )
            {
            // Flowthrough, doesn't matter which key was pressed since
            // the value is always changes from "off" to "on" or vice versus.
            case EStdKeyDevice3: // selection key
            case EStdKeyLeftArrow:
            case EStdKeyRightArrow:
                iStatus = !iStatus; // change status
                ResetFieldL();
                response = EKeyWasConsumed;
                break;

            default:
                break;
            }
        }
    return response;
    }

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

    iLabel->SetFocus( aFocus );
    
    if( aFocus ) //Focus is gained on the field
        {
        if ( iStatus )
            {
            ChangeMiddleSoftKeyL( EESMRCmdAlarmOff,R_QTN_MEET_REQ_ALARM_OFF ); //R_TEXT_SOFTKEY_OFF
            }
        else
            {
            ChangeMiddleSoftKeyL( EESMRCmdAlarmOn,R_QTN_MEET_REQ_ALARM_ON ); //R_TEXT_SOFTKEY_ON
            }
        }
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::MakeVisible
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::MakeVisible( TBool aVisible )
    {
    FUNC_LOG;
    CCoeControl::MakeVisible( aVisible );
    if ( iObserver )
        {
        TRAP_IGNORE( ResetFieldL() );
        }
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::ExecuteGenericCommandL()
// ---------------------------------------------------------------------------
//
TBool CMRAlarmOnOffField::ExecuteGenericCommandL( TInt aCommand )
    {
    FUNC_LOG;
    TBool isUsed( EFalse );
    // EAknCmdOpen is added for the Pointer events, see ListPane
    if( aCommand == EESMRCmdAlarmOn || aCommand == EESMRCmdAlarmOff 
            || aCommand == EAknCmdOpen )
        {    
        SwitchMiddleSoftKeyL();
        isUsed = ETrue;
        
		HandleTactileFeedbackL();
        }
    return isUsed;
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::SwitchMiddleSoftKeyL
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::SwitchMiddleSoftKeyL()
    {
    FUNC_LOG;
    iStatus = !iStatus; // change status
    ResetFieldL();
    if( iStatus )
        {
        ChangeMiddleSoftKeyL( EESMRCmdAlarmOff,R_QTN_MEET_REQ_ALARM_OFF ); 
        }
    else
        {
        ChangeMiddleSoftKeyL( EESMRCmdAlarmOn,R_QTN_MEET_REQ_ALARM_ON ); 
        }
    
    if( iLabel->IsVisible() )
        {
        iLabel->DrawDeferred();
        }
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::ResetFieldL
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::ResetFieldL()
    {
    FUNC_LOG;
    iValidator->SetAlarmOnOffL( iStatus );

    HBufC* buf = StringLoader::LoadLC( iStatus ?
    R_QTN_MEET_REQ_ALARM_ON :
    R_QTN_MEET_REQ_ALARM_OFF );

    iLabel->SetTextL( *buf );
    CleanupStack::PopAndDestroy( buf );

    // if status on 'on', add time and date fields for
    // all day event alert, otherwise remove them.
    // if this field is not visible -> alldayevent not set
    // let's not show the date and time fields either.
    if ( iStatus && IsVisible() )
        {
        iObserver->ShowControl ( EESMRFieldAlarmTime );
        iObserver->ShowControl ( EESMRFieldAlarmDate );
        }
    else
        {
        iObserver->HideControl ( EESMRFieldAlarmTime );
        iObserver->HideControl ( EESMRFieldAlarmDate );
        }
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::SizeChanged()
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::SizeChanged()
    {
    FUNC_LOG;
    TRect rect = Rect();
    TAknLayoutRect rowLayoutRect =
     NMRLayoutManager::GetFieldRowLayoutRect( rect, 1 );
    rect = rowLayoutRect.Rect();
    
    TAknWindowComponentLayout iconLayout =
     NMRLayoutManager::GetWindowComponentLayout( 
             NMRLayoutManager::EMRLayoutTextEditorIcon );
    AknLayoutUtils::LayoutImage( iIcon, rect, iconLayout );
    
    TAknLayoutRect bgLayoutRect =
     NMRLayoutManager::GetLayoutRect( 
             rect, NMRLayoutManager::EMRLayoutTextEditorBg );
    TRect bgRect( bgLayoutRect.Rect() );
    // Move focus rect so that it's relative to field's position.
    bgRect.Move( -Position() );
    SetFocusRect( bgRect );
    
    TAknLayoutText labelLayout = 
     NMRLayoutManager::GetLayoutText( 
             rect, NMRLayoutManager::EMRTextLayoutTextEditor );
    iLabel->SetRect( labelLayout.TextRect() );
    
    // Setting font for the label also
    iLabel->SetFont( labelLayout.Font() );
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::CountComponentControls()
// ---------------------------------------------------------------------------
//
TInt CMRAlarmOnOffField::CountComponentControls() const
    {
    FUNC_LOG;
    TInt count( 0 );
    if ( iIcon )
        {
        ++count;
        }

    if ( iLabel )
        {
        ++count;
        }
    return count;
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::ComponentControl()
// ---------------------------------------------------------------------------
//
CCoeControl* CMRAlarmOnOffField::ComponentControl( TInt aIndex ) const
    {
    FUNC_LOG;
    switch ( aIndex )
        {
        case 0:
            return iIcon;
        case 1:
            return iLabel;
        default:
            return NULL;
        }
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::SetContainerWindowL
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::SetContainerWindowL( 
        const CCoeControl& aContainer )
    {
    FUNC_LOG;
    CCoeControl::SetContainerWindowL( aContainer );
    iLabel->SetContainerWindowL( aContainer );
    iLabel->SetParent( this );
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::SetAbsoluteAlarmOn
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::SetAbsoluteAlarmOn()
    {
    FUNC_LOG;
    iStatus = ETrue;
    }

// ---------------------------------------------------------------------------
// CMRAlarmOnOffField::SetAbsoluteAlarmOn
// ---------------------------------------------------------------------------
//
void CMRAlarmOnOffField::SetAbsoluteAlarmOff()
    {
    FUNC_LOG;
    iStatus = EFalse;
    }

// EOF