/*

* 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:  The class of handwriting box container implemention.

*

*/

#include <peninputlayout.h>

#include <aknfeppeninputenums.h>    //command from fep or IME to plugin. for vkb/hwr : ESignalCapturePointer

#include "peninputhwrboxgroup.h"

#include "peninputhwrevent.h"

// Implementation of Class CPeninputHwrBoxGroup

// The container class of HWR boxes

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

// CPeninputHwrBoxGroup::NewL

// factory function

// (other items were commented in a header).

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

//

CPeninputHwrBoxGroup* CPeninputHwrBoxGroup::NewL(CFepUiLayout* aUiLayout,

                                             TInt aBoxGroupId,

                                             TInt aBoxCount)

    {

    CPeninputHwrBoxGroup* self = new (ELeave) CPeninputHwrBoxGroup(aUiLayout, aBoxGroupId);

    CleanupStack::PushL(self);

    self->ConstructL(aBoxCount);

    CleanupStack::Pop(self);

    return self;

    }

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

// CPeninputHwrBoxGroup::NewLC

// factory function

// (other items were commented in a header).

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

//

CPeninputHwrBoxGroup* CPeninputHwrBoxGroup::NewLC(CFepUiLayout* aUiLayout,

                                              TInt aBoxGroupId,

                                              TInt aBoxCount)

    {

    CPeninputHwrBoxGroup* self = new (ELeave) CPeninputHwrBoxGroup(aUiLayout, aBoxGroupId);

    CleanupStack::PushL(self);

    self->ConstructL(aBoxCount);

    return self;

    }

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

// CPeninputHwrBoxGroup::~CPeninputHwrBoxGroup

// Destructor

// (other items were commented in a header).

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

//

CPeninputHwrBoxGroup::~CPeninputHwrBoxGroup()

    {

    // base class CControlGroup frees all controls in the list

    }

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

// CPeninputHwrBoxGroup::HandlePointerDownEventL

// Handle pointer down event

// (other items were commented in a header).

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

CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerDownEventL(const TPoint& aPoint)

    {

    if(iDimmed)

        {

        CapturePointer();

        return NULL;

        }

    return CControlGroup::HandlePointerDownEventL(aPoint);

    }

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

// CPeninputHwrBoxGroup::HandlePointerMoveEventL

// Handle pointer move event

// (other items were commented in a header).

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

CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerMoveEventL(const TPoint& aPoint)

    {

    if(iDimmed)

        {

        return NULL;

        }

    return CControlGroup::HandlePointerMoveEventL(aPoint);

    }

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

// CPeninputHwrBoxGroup::HandlePointerUpEventL

// Handle pointer up event

// (other items were commented in a header).

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

CFepUiBaseCtrl* CPeninputHwrBoxGroup::HandlePointerUpEventL(const TPoint& aPoint)

    {

    if(iDimmed)

        {

        TBool capture = ETrue;

        TPtrC captureData;

        captureData.Set((const TUint16*)&capture,sizeof(TBool)/sizeof(TUint16));

        CapturePointer(EFalse);

        UiLayout()->SignalOwner(ESignalCapturePointer,captureData);

        return NULL;

        }

    return CControlGroup::HandlePointerUpEventL(aPoint);

    }

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

// CPeninputHwrBoxGroup::HandlePointerLeave

// Handle pointer leave  event

// (other items were commented in a header).

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

void CPeninputHwrBoxGroup::HandlePointerLeave(const TPoint& aPoint)

    {

    if(iDimmed)

        {

        return;

        }

    CControlGroup::HandlePointerLeave(aPoint);

    }

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

// CPeninputHwrBoxGroup::HandlePointerEnter

// Handle pointer enter  event

// (other items were commented in a header).

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

void CPeninputHwrBoxGroup::HandlePointerEnter(const TPoint& aPoint)

    {

    if(iDimmed)

        {

        return;

        }

    CControlGroup::HandlePointerEnter(aPoint);

    }

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

// CPeninputHwrBoxGroup::BoxCount

// Clear current handwriting trail if any.

// (other items were commented in a header).

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

//

TInt CPeninputHwrBoxGroup::BoxCount()

    {

    return NumOfControls();

    }

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

// CPeninputHwrBoxGroup::CancelWriting

// Clear current handwriting trail if any.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::CancelWriting()

    {

    if( iActiveBox == NULL )

        {

        //there is nothing to cancel

        return;

        }

    iActiveBox->SetWndTransparencyFactor(iInactiveTrans);

    iActiveBox->CancelCharWriting();

    }

const RArray<TPoint>& CPeninputHwrBoxGroup::StrokeList()

    {

    ASSERT( iActiveBox != NULL );

    return iActiveBox->StrokeList();

    }

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

// CPeninputHwrBoxGroup::SizeChanged

// Hand size change event.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SizeChanged(const TRect& aRect)

    {

    TInt boxWidth = aRect.Width() / NumOfControls();

    TInt curLeft = aRect.iTl.iX;

    SetRect(aRect);

    for( TInt j = 0; j < NumOfControls(); j++, curLeft += boxWidth )

        {

        CTransparentHwrWnd* ctrl = static_cast<CTransparentHwrWnd*>(At(j));

        ctrl->SetRect( TRect(curLeft, aRect.iTl.iY,

                              curLeft + boxWidth,

                              aRect.iBr.iY) );

        // Set guide line information

        TRect rect(TPoint(0,0), TSize(boxWidth, aRect.Height()));

        TInt arc = (rect.Width() < rect.Height())? rect.Width() : rect.Height();

        TInt unit = arc / 8;

        TRect toprect( rect.Width()/2 - unit*4, unit + aRect.iTl.iY,

                    rect.Width()/2 + unit*4, unit + aRect.iTl.iY );

        TRect bottomrect( rect.Width()/2 - unit*4, unit*7 + aRect.iTl.iY,

                    rect.Width()/2 + unit*4, unit*7 + aRect.iTl.iY);

        // default black

        }

    RefreshUI();

    }

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

// CPeninputHwrBoxGroup::SetBoxBackColor

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetBoxBackColor(const TRgb& aCol)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        At(j)->SetBkColor(aCol);

        }

    }

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

// CPeninputHwrBoxGroup::SetBoxFrameColor

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetBoxFrameColor(const TRgb& aCol)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        static_cast<CTransparentHwrWnd*>(At(j))->SetFrameCol(aCol);

        }

    }

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

// CPeninputHwrBoxGroup::SetStrokEndMark

// Iterate to set each HWR box stroke end mark.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetStrokeEndMark(const TPoint& aEndMard)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        static_cast<CTransparentHwrWnd*>(At(j))->SetStrokeEndMark(aEndMard);

        }

    }

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

// CPeninputHwrBoxGroup::SetTransparency

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetTransparency(const TUint8 aActiveTrans, const TUint8 aInactiveTrans)

    {

#ifdef __ALPHA_TRANCEPARENCY__

    iActiveTrans = aActiveTrans;

    iInactiveTrans = aInactiveTrans;

#else

    iActiveTrans = 255 - aActiveTrans;

    iInactiveTrans = 255 - aInactiveTrans;

#endif

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        if( At(j) != iActiveBox)

            {

            static_cast<CTransparentHwrWnd*>(At(j))->SetWndTransparencyFactor(iInactiveTrans);

            }

        else

            {

            static_cast<CTransparentHwrWnd*>(At(j))->SetWndTransparencyFactor(iActiveTrans);

            }

        }

    }

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

// from base class MEventObserver

// CPeninputHwrBoxGroup::HandleEvent

// Clear current handwriting trail if any.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::HandleControlEvent(TInt aEventType,

                                           CFepUiBaseCtrl* aCtrl,

                                           const TDesC& /*aEventData*/)

    {

    CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>( aCtrl );

    switch( aEventType )

        {

        case EEventHwrStrokeStarted:

            ReportEvent(aEventType);   // for DisableCaseChange

            OnStrokeStarted(hwrWnd);

            break;

        case EEventHwrStrokeFinished:

            OnStrokeFinished(hwrWnd);

            break;

        case EEventHwrCharacterTimerOut:

            ReportEvent(aEventType);   // for EnableCaseChange

            OnStrokeCharacterTimerOut(hwrWnd);

            break;

        case EEventHwrStrokeCanceled:

            ReportEvent(aEventType);   // for EnableCaseChange

            OnStrokeCanceled(hwrWnd);

            break;

        default:

            // not handle other event type

            break;

        }

    }

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

// CPeninputHwrBoxGroup::CPeninputHwrBoxGroup

// C++ constructor.

// (other items were commented in a header).

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

//

CPeninputHwrBoxGroup::CPeninputHwrBoxGroup(CFepUiLayout* aUiLayout, TInt aBoxGroupId)

    : CControlGroup(aUiLayout, aBoxGroupId),

    iDimmed(EFalse)

    {

    }

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

// CPeninputHwrBoxGroup::ConstructL

// Symbian secode phase constructor.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::ConstructL(TInt aBoxCount)

    {

    //leave if invalid aBoxCount

    ASSERT( aBoxCount > 0 );

    //call base construct

    CControlGroup::ConstructL();

    //create two box hwr window

    for( TInt i = 0; i < aBoxCount; ++i )

        {

        CTransparentHwrWnd* aBox = CTransparentHwrWnd::NewL(TRect(),

                                                            UiLayout(),

                                                            0,

                                                            EFalse);

        CleanupStack::PushL( aBox );

        aBox->AddEventObserver( this );

        aBox->EnableTraceOutsideWindow(EFalse);

        AddControlL(aBox);

        CleanupStack::Pop(aBox); //aBox

       }

    }

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

// CPeninputHwrBoxGroup::SetWritingSpeed

// Iterate to set each HWR box writting speed.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetWritingSpeed(const TTimeIntervalMicroSeconds32& aCharDelay)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>(At(j));

        if( hwrWnd != NULL )

            {

            hwrWnd->SetCharacterDelay(aCharDelay);

            }

        }

    }

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

// CPeninputHwrBoxGroup::SetStrokeDelay

// Iterate to set each HWR box writting speed.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetStrokeDelay(const TTimeIntervalMicroSeconds32& aCharDelay)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        CTransparentHwrWnd* hwrWnd = static_cast<CTransparentHwrWnd*>(At(j));

        if( hwrWnd != NULL )

            {

            hwrWnd->SetStrokeDelay(aCharDelay);

            }

        }

    }

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

// CPeninputHwrBoxGroup::SetBoxPenSize

// Iterate to set each HWR box trail drawing pen size.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetBoxPenSize(const TSize& aSize)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        At(j)->SetPenSize(aSize);

        }

    }

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

// CPeninputHwrBoxGroup::SetBoxPenColor

// Iterate to set each HWR box trail drawing pen color.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::SetBoxPenColor(const TRgb& aCol)

    {

    for( TInt j = 0; j < NumOfControls(); j++ )

        {

        At(j)->SetPenColor(aCol);

        }

    }

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

// CPeninputHwrBoxGroup::OnStrokeStarted

// Handle EEventHwrStrokeStarted event.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::OnStrokeStarted(CTransparentHwrWnd* aBoxFrom)

    {

    TBool refresh = EFalse;

    if( iActiveBox == NULL )

        {

        //change state from not writing to begin writing

        iActiveBox = aBoxFrom;

        refresh = ETrue;

        ReportEvent(EPeninputLayoutHwrEventBeginWriting);

        //set current box transparency

        iActiveBox->SetWndTransparencyFactor(iActiveTrans);

        }

    else

        {

        if( iActiveBox != aBoxFrom )

            {

            // current active box will turn into inactive state

            iActiveBox->SetWndTransparencyFactor(iInactiveTrans);

            // user switches to another box

            if( iActiveBox->HasNewTrace() )

                {

                OnStrokeFinished(iActiveBox);

                }

            // handler of EPeninputLayoutHwrEventNewWriting submit default candidate

            // reset state

            ReportEvent(EPeninputLayoutHwrEventNewWriting);

            // clear writing of the last box

            CancelWriting();

            iActiveBox = aBoxFrom;

            refresh = ETrue;

            //set current box transparency

            iActiveBox->SetWndTransparencyFactor(iActiveTrans);

            }

        else

            {

            ReportEvent(EPeninputLayoutHwrEventBeginWriting);

            }

        }

    if( refresh )

        {

        // only active box need update

        // inactive box is already update by CancelWriting

        RefreshUI(iActiveBox);

        }

    }

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

// CPeninputHwrBoxGroup::StrokeStrokeFinished

// Handle EEventHwrStrokeFinished event.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::OnStrokeFinished(CTransparentHwrWnd* /* aBoxFrom */)

    {

    // Get stroke list is called by event handler

    TPtrC ptr;

    RArray<TPoint>* strokeList = const_cast<RArray<TPoint>* >(&(StrokeList()));

    ptr.Set(reinterpret_cast<TText*>(strokeList), sizeof(strokeList)/sizeof(TUint16));

    ReportEvent(EPeninputLayoutHwrEventEndStroke, ptr);

    }

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

// CPeninputHwrBoxGroup::StrokeCharacterTimerOut

// Handle EEventHwrCharacterTimerOut event.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::OnStrokeCharacterTimerOut(CTransparentHwrWnd* aBoxFrom)

    {

    aBoxFrom->SetWndTransparencyFactor(iInactiveTrans);

    ReportEvent(EPeninputLayoutHwrEventEndWriting);

    if( iActiveBox == aBoxFrom )

        {

        iActiveBox = NULL;

        }

    RefreshUI(aBoxFrom);

    }

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

// CPeninputHwrBoxGroup::OnStrokeCanceled

// Handle EEventHwrStrokeCanceled event.

// (other items were commented in a header).

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

//

void CPeninputHwrBoxGroup::OnStrokeCanceled(const CTransparentHwrWnd* aBoxFrom)

    {

    if( iActiveBox == aBoxFrom )