/*

* Copyright (c) 2006-2006 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 full screen UI layout

*

*/

#include <w32std.h>

#include <peninputcmd.h>

#include "peninputfullscrlayout.h"

#include "peninputlayoutrootctrl.h"

#include "peninputlayouttimer.h"

#include "peninputlayouthwrwnd.h"

#include <coemain.h>

const TInt KDefaultMaxStep = 3;

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

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

// CFepFullScreenLayout::CFepFullScreenLayout

// Constructor

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

//

EXPORT_C CFepFullScreenLayout::CFepFullScreenLayout(MLayoutOwner* aLayoutOwner,

                                TInt aDuration)

                               :CFepUiLayout(aLayoutOwner),

                               iBufferEvent(EFalse),iXLeftPos(0),iXRightPos(0),

                               iYTopPos(0),iYBottomPos(0),

                               iEventBufDruation(aDuration)

    {

    const TInt KDefaultBufferTimer = 1000*250; //1/4 seconds            

    if(iEventBufDruation <= 0)

        iEventBufDruation = KDefaultBufferTimer;

    }

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

// CFepFullScreenLayout::~CFepFullScreenLayout

// Destructor

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

//

EXPORT_C CFepFullScreenLayout::~CFepFullScreenLayout()

    {

    delete iBufferTimer;    

    } 

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

// CFepFullScreenLayout::BaseConstructL

// Do basic contructor

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

//

EXPORT_C void CFepFullScreenLayout::BaseConstructL()

    {

    iBufferTimer = CLayoutTimer::NewL(this,CLayoutTimer::EOthers);

    CFepUiLayout::BaseConstructL();

    }

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

// CFepUiLayout::HandleEventL

// handle event from window server

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

//

EXPORT_C TBool CFepFullScreenLayout::HandleEventL(TEventType aType, const TAny* aData)

    {   

    TRawEvent event=*((TRawEvent*)aData);    

    //if pointer is captured, don't buffer the event.

    if(RootControl()->CtrlCapPointer())

        return CFepUiLayout::HandleEventL(aType,aData);        

    if((ERawEvent == aType) && (TRawEvent::EButton1Down == event.Type() ||

                                TRawEvent::EButton1Up == event.Type() || 

                                TRawEvent::EPointerMove == event.Type()) )

        {

        if(iBufferEvent)

            {

            if(TRawEvent::EButton1Up == event.Type())        

                {

                //is the buffer timer still active? if so, cancel it and

                //simulate the event to others

                if(iBufferTimer->IsActive())

                    {

                    iEventBuf.Append(event);

                    SimulateEvent();

                    return ETrue;

                    }

                else

                    {

                    //is this a valid trace?

                    iEventBuf.Append(event);

                    if(IsValidStroke())

                        HandleBufferedEventL();

                    else

                        SimulateEvent();

                    return ETrue;

                    }

                }

            BufferEventL(event);

            return ETrue;

            }

        //Check whether buffering should starts.

        //Only when pen downs in the area where trace can be started,

        //e.g, not in the button, should we start the buffering.

        if(!(RootControl()->NonHwrStartingPtRegion().Contains(event.Pos())))

            {            

            if(IsHwrNewCharacter() && TRawEvent::EButton1Down == event.Type())

                {                

                StartBufferEvent(event);

                return ETrue;

                }

            }

        }

    return CFepUiLayout::HandleEventL(aType,aData);    

    }

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

// CFepFullScreenLayout::StartBufferEvent

// Start bufferring the event

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

//    

void CFepFullScreenLayout::StartBufferEvent(TRawEvent& aEvent)

    {

    iBufferEvent = ETrue;

    iXLeftPos = aEvent.Pos().iX;

    iXRightPos = aEvent.Pos().iX;

    iYTopPos = aEvent.Pos().iY;

    iYBottomPos = aEvent.Pos().iY;

    iEventBuf.Append(aEvent);

    iHwrWndPenSize = iHwrWnd->PenSize();

    iHwrWnd->SetPenSize(TSize(0,0));

    iBufferTimer->SetTimer(iEventBufDruation); 

    }

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

// CFepFullScreenLayout::BufferEventL

// Bufferring theevent

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

//

void CFepFullScreenLayout::BufferEventL(TRawEvent& aEvent)

    {

    iEventBuf.AppendL(aEvent);

    if(IsValidStroke())

        HandleBufferedEventL();

    }

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

// CFepFullScreenLayout::SimulateEvent

// Simulates the bufferred event to other app

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

//

void CFepFullScreenLayout::SimulateEvent()

    {

    iBufferEvent = EFalse;

    //resotre the hwr window pen size

    iHwrWnd->SetPenSize(iHwrWndPenSize);    

    for(TInt i = 0; i < iEventBuf.Count(); i++)

        { 

    	TPtrC data;

    	data.Set(reinterpret_cast<TUint16*>(&iEventBuf[i]),sizeof(iEventBuf[i])/sizeof(TUint16));

        SignalOwner(ESignalSimulateEvent,data);

        } 

    iEventBuf.Reset();            

    }

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

// CFepFullScreenLayout::HandleBufferedEventL

// Forward event to iput UI

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

//    

void CFepFullScreenLayout::HandleBufferedEventL()

    {

    iBufferEvent = EFalse;

    //resotre the hwr window pen size

    iHwrWnd->SetPenSize(iHwrWndPenSize);    

    for(TInt i = 0; i < iEventBuf.Count(); i++)

        {

        CFepUiLayout::HandleEventL(ERawEvent,&iEventBuf[i]);

        }

    iEventBuf.Reset();

    }

EXPORT_C void CFepFullScreenLayout::HandleTimerOut(TInt /*aTimeType*/)

    {

    iBufferEvent = EFalse;

    //change pen width for hwr window

    TRAP_IGNORE(HandleBufferedEventL());

    }

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

// CFepFullScreenLayout::InitL

// Initialize the layout

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

//

EXPORT_C TRect CFepFullScreenLayout::Init()

    {

    //find hwr window

    iHwrWnd =(CHwrWndBase*)(RootControl()->ControlForKindOfType(ECtrlTransparentHwrWnd));

    __ASSERT_ALWAYS(iHwrWnd, User::Panic(_L("peninputserver"), EUiFullscreenWithoutHWRWnd));

    return CFepUiLayout::Init();

    }

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

// CFepFullScreenLayout::IsHwrNewCharacter

// Test whether a new character is starting

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

//

EXPORT_C TBool CFepFullScreenLayout::IsHwrNewCharacter()

    {

    return iHwrWnd->StrokeList().Count() <= 0;

    }

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

// CFepFullScreenLayout::SemiTransparencyRequired

// Tell whether this layout require trancparency

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

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

//       

EXPORT_C TBool CFepFullScreenLayout::SemiTransparencyRequired()    

    {

    //full screen HWR using full-transparency, so black-white mask is OK.

    return EFalse;

    }

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

// CFepFullScreenLayout::IsValidStroke

// Tests whether current pen trace is valid for a character

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

//

EXPORT_C TBool CFepFullScreenLayout::IsValidStroke()

    {

    if(iEventBuf.Count() >= KMaxBufferEventNum)

        {

        return ETrue; //buffer overflow, this is considering to be a valid stroke.

        }

    TPoint pt = iEventBuf[iEventBuf.Count()-1].Pos();

    if(pt.iX < iXLeftPos)

        {

        iXLeftPos = pt.iX;

        }

    else

        {

        if(pt.iX > iXRightPos)

            {

            iXRightPos = pt.iX;

            }

        }

    if(pt.iY < iYTopPos)

        {

        iYTopPos = pt.iY;

        }

    else

        {

        if(pt.iY > iYBottomPos)

            {

            iYBottomPos = pt.iY;

            }

        }    

    if((iXRightPos - iXLeftPos) >= KDefaultMaxStep || 

       (iYBottomPos - iYBottomPos) >= KDefaultMaxStep)

        {        

        //HandleBufferedEventL();

        return ETrue;

        }

    else

        return EFalse;    

    }

//end of file