/*

* Copyright (c) 2002-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: 

*       Common control container class for Phonebook 2 application.

*

*/

// INCLUDE FILES

#include "CPbk2ControlContainer.h"

// Phonebook 2

#include <MPbk2KeyEventHandler.h>

#include <MPbk2PointerEventHandler.h>

// SYSTEM INCLUDES

#include <AknUtils.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPostCond_Constructor = 1,

    EPanicPreCond_ConstructL,

    EPanicPostCond_ConstructL,

    EPanicPostCond_DestroyControl,

    EPanicPreCond_SetCoeControlL,

    EPanicPostCond_SetCoeControlL,

    EPanicPreCond_ComponentControl,

    };

void Panic(TPanicCode aReason)

    {

    _LIT( KPanicText, "CPbk2ControlContainerImpl" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

} // namespace

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

// CPbk2ControlContainerImpl::CPbk2ControlContainerImpl

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

//

EXPORT_C CPbk2ControlContainerImpl::CPbk2ControlContainerImpl

        ( MPbk2KeyEventHandler* aKeyEventHandler,

          MPbk2PointerEventHandler* aPointerHandler ) :

            iKeyEventHandler( aKeyEventHandler ),

            iPointerEventHandler( aPointerHandler )

    {

    SetComponentsToInheritVisibility( ETrue );

    __ASSERT_DEBUG(!iControl, Panic(EPanicPostCond_Constructor));

    }

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

// CPbk2ControlContainerImpl::~CPbk2ControlContainerImpl

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

//

EXPORT_C CPbk2ControlContainerImpl::~CPbk2ControlContainerImpl()

    {

    if (iOwnsControl)

        {

        delete iControl;

        }

    delete iLongTapDetector;

    }

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

// CPbk2ControlContainerImpl::ConstructL

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

//

EXPORT_C void CPbk2ControlContainerImpl::ConstructL

        ( MObjectProvider& aProvider )

    {

    // PreCond

    __ASSERT_DEBUG(!iControl, Panic(EPanicPreCond_ConstructL));

    SetMopParent(&aProvider);

    // Create a window, this is the top-level container control

    CreateWindowL();

    // PostCond

    __ASSERT_DEBUG(!iControl && OwnsWindow(), Panic(EPanicPostCond_ConstructL));

    }

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

// CPbk2ControlContainerImpl::CoeControl

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

//

EXPORT_C CCoeControl* CPbk2ControlContainerImpl::CoeControl() const

    {

    return iControl;

    }

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

// CPbk2ControlContainerImpl::DestroyControl

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

//

EXPORT_C void CPbk2ControlContainerImpl::DestroyControl()

    {

    if (iOwnsControl)

        {

        delete iControl;

        iControl = NULL;

        __ASSERT_DEBUG(!CoeControl(), Panic(EPanicPostCond_DestroyControl));

        }

    }

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

// CPbk2ControlContainerImpl::KeyEventHandler

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

//

EXPORT_C MPbk2KeyEventHandler*

        CPbk2ControlContainerImpl::KeyEventHandler() const

    {

    return iKeyEventHandler;

    }

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

// CPbk2ControlContainerImpl::PointerEventHandler

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

//

EXPORT_C MPbk2PointerEventHandler*

        CPbk2ControlContainerImpl::PointerEventHandler() const

    {

    return iPointerEventHandler;

    }    

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

// CPbk2ControlContainerImpl::SetKeyEventHandler

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

//

EXPORT_C void CPbk2ControlContainerImpl::SetKeyEventHandler

        (MPbk2KeyEventHandler* aKeyEventHandler)

    {

    iKeyEventHandler = aKeyEventHandler;

    }

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

// CPbk2ControlContainerImpl::SetHelpContext

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

//

EXPORT_C void CPbk2ControlContainerImpl::SetHelpContext

        (const TCoeHelpContext& aContext)

    {

    iHelpContext = aContext;

    }

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

// CPbk2ControlContainerImpl::GetHelpContext

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

//

EXPORT_C void CPbk2ControlContainerImpl::GetHelpContext

        (TCoeHelpContext& aContext) const

    {

    aContext = iHelpContext;

    }

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

// CPbk2ControlContainerImpl::LongTapDetectorL

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

//

EXPORT_C CAknLongTapDetector& CPbk2ControlContainerImpl::LongTapDetectorL()

    {

    if ( !iLongTapDetector )

        {

        iLongTapDetector = CAknLongTapDetector::NewL( this );

        }

    return *iLongTapDetector;

    }

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

// CPbk2ControlContainerImpl::SetCoeControl

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

//

EXPORT_C void CPbk2ControlContainerImpl::SetCoeControl(

        CCoeControl* aControl,

        const TRect& aRect,

        TBool aOwnsControl /* = ETrue */ )

    {

    __ASSERT_DEBUG(OwnsWindow(), Panic(EPanicPreCond_SetCoeControlL));

    // Set the control

    if (aControl != iControl)

        {

        if (iOwnsControl)

            {

            delete iControl;

            }

        iControl = aControl;

        }

    // Store ownership request

    iOwnsControl = aOwnsControl;

    RemoveForegroundObserver();

    // Set rectangle

    SetRect(aRect);

    __ASSERT_DEBUG(CoeControl()==aControl, Panic(EPanicPostCond_SetCoeControlL));

    }

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

// CPbk2ControlContainerImpl::OfferKeyEventL

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

//

EXPORT_C TKeyResponse CPbk2ControlContainerImpl::OfferKeyEventL

        (const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

    ("CPbk2ControlContainerImpl::OfferKeyEventL(0x%x),Code=%d,Mod=%x,Type=%d"), 

        this, aKeyEvent.iCode, aKeyEvent.iModifiers, aType );

    TKeyResponse ret = EKeyWasNotConsumed;

    // Offer key event first to the key event handler

    if ( iKeyEventHandler && iKeyEventHandler->Pbk2ProcessKeyEventL

            ( aKeyEvent, aType ) )

        {

        ret = EKeyWasConsumed;

        }

    // Not consumed by the key handler, offer to the control next

    if ( ( ret == EKeyWasNotConsumed ) && iControl )

        {

        ret = iControl->OfferKeyEventL( aKeyEvent, aType );

        }

    return ret;

    }

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

// CPbk2ControlContainerImpl::CountComponentControls

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

//

EXPORT_C TInt CPbk2ControlContainerImpl::CountComponentControls() const

    {

    // iControl is the only subcontrol

    return iControl ? 1 : 0;

    }

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

// CPbk2ControlContainerImpl::ComponentControl

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

//

EXPORT_C CCoeControl* CPbk2ControlContainerImpl::ComponentControl

        ( TInt PBK2_DEBUG_ONLY( aIndex ) ) const

    {

    // PreCond: Assert that the control is assigned and aIndex is sensible

    __ASSERT_DEBUG( iControl && aIndex == 0,

        Panic( EPanicPreCond_ComponentControl ) );

    // iControl is the only subcontrol

    return iControl;

    }

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

// CPbk2ControlContainerImpl::SizeChanged

// This control is only a container; sets iControl's rectangle

// to this control's rectangle.

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

//

EXPORT_C void CPbk2ControlContainerImpl::SizeChanged()

    {

    if ( iControl )

        {

        // Set the control's rectangle to fill this container's rectangle

        iControl->SetRect( Rect() );

        }

    }

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

// CPbk2ControlContainerImpl::FocusChanged

// Forwards focus changed events.

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

//

EXPORT_C void CPbk2ControlContainerImpl::FocusChanged( TDrawNow aDrawNow )

    {

    if ( iControl && !IsNonFocusing() )

        {

        iControl->SetFocus( IsFocused(), aDrawNow );

        }

    if ( iObserver && iControl )

        {

        TRAP_IGNORE( iObserver->HandleForegroundEventL( IsFocused() ) );

        }

    }

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

// CPbk2ControlContainerImpl::HandlePointerEventL

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

//    

EXPORT_C void CPbk2ControlContainerImpl::HandlePointerEventL(

        const TPointerEvent& aPointerEvent )

    {    

    if ( AknLayoutUtils::PenEnabled() )

        { 

        // Offer pointer event first to the control

        if (  iControl )

            {

            iControl->HandlePointerEventL( aPointerEvent );

            }           

        // Offer pointer event next to the pointer event handler        

        if ( iPointerEventHandler )    

            {

            iPointerEventHandler->Pbk2ProcessPointerEventL( aPointerEvent );

            }             

        }

    }

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

// CPbk2ControlContainerImpl::HandleLongTapEventL

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

//    

EXPORT_C void CPbk2ControlContainerImpl::HandleLongTapEventL(

        const TPoint& aPenEventLocation, 

        const TPoint& aPenEventScreenLocation )

    {

    if ( AknLayoutUtils::PenEnabled() )

        { 

        // Offer long tap event to the pointer event handler

        if ( iPointerEventHandler )    

            {

            iPointerEventHandler->Pbk2HandleLongTapEventL(

                aPenEventLocation, aPenEventScreenLocation );

            }             

        }

    }

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

// CPbk2ControlContainerImpl::AddForegroundObserver

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

// 

EXPORT_C void CPbk2ControlContainerImpl::AddForegroundObserver

        ( MPbk2ControlContainerForegroundEventObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CPbk2ControlContainerImpl::RemoveForegroundObserver

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

// 

EXPORT_C void CPbk2ControlContainerImpl::RemoveForegroundObserver()

    {

    iObserver = NULL;

    }

//  End of File