/*

* Copyright (c) 2005-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 hwr window base and transparent window

*

*/

#include <coemain.h>

#include "peninputlayouthwrwnd.h"

#include "peninputlayoutrootctrl.h"

#include "peninputlayouttimer.h"

#include "peninputlayout.h"

#include <settingsinternalcrkeys.h>

#include "peninputpentracedecorator.h"

const TUint8 KDefaultTransparency = 128;

const TInt KDefaultPenSize = 3;

const TInt KFadeAreaCount = 30;

/******************** start of CHwrWndBase **********************************/

// Implementation of Class CHwrWndBase

//

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

// CHwrWndBase::CHwrWndBase

// C++ default constructor

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

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

//

EXPORT_C CHwrWndBase::CHwrWndBase(const TRect& aRect,CFepUiLayout* aUiLayout,TInt aControlId):

                    CFepUiBaseCtrl(aRect,aUiLayout,aControlId), 

                    iHasNewTrace(EFalse),

                    iSubmitted(ETrue)

    {

    const TTimeIntervalMicroSeconds32 KDefaultCharDelay = 1000*500; //1/2 seconds    

    const TTimeIntervalMicroSeconds32 KDefaultStrokeDelay = 1000*300; //1/10 seconds

    SetControlType(ECtrlHwrWnd);

    SetPenColor(KRgbBlack);

    SetPenSize(TSize(KDefaultPenSize,KDefaultPenSize));

    iStrokeEndMark=TPoint(0xffff,0);

    iStrokeDelay = KDefaultStrokeDelay;    

    iCharDelay = KDefaultCharDelay;    

    iDirtyRect.SetRect(0,0,0,0);

    }

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

// CHwrWndBase::~CHwrWndBase

// Destructor

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

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

//

EXPORT_C CHwrWndBase::~CHwrWndBase()

    {

    iListOfPoints.Close();

    delete iCharacterTimer;

    iCharacterTimer = NULL;

    delete iStrokeTimer;

    iStrokeTimer = NULL;     

    }

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

// CHwrWndBase::ClearStroke

// Clear the stroke

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

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

//   

EXPORT_C void CHwrWndBase::ClearStroke()

    {

    iDirtyRect.Intersection(iRect);

    ClearRect( iRect );       

    iListOfPoints.Reset();            

    iHasNewTrace=EFalse;

    iSubmitted = ETrue;

    if(AbleToDraw())

        {

        RootControl()->DrawRect(iRect);

        UpdateArea(iRect, EFalse);

        }

    iDirtyRect.SetRect(0,0,0,0);        

    }

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

// CHwrWndBase::AddGuidingLine

// Add a guilding line.

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

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

// 

EXPORT_C void CHwrWndBase::AddGuidingLine(const TPoint& /*aStart*/, const TPoint& /*aEnd*/)

    {

    //not implemented

    }

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

// CHwrWndBase::EndStrokeL

// Do recognition after a stroke is ended.

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

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

//   

    {

    if(iHasNewTrace)    //only do this when we have new trace

        {               

        if(aCharacterTimerFlag)

            {

            iCharacterTimer->SetTimer(iCharDelay);  //set character timer            

            //only send finish event when character timer starter, 

            //otherwise, send charater timer out event.

            ReportEvent(EEventHwrStrokeFinished); 

            iSubmitted = EFalse;

            }            

        else

            {

            ReportEvent(EEventHwrCharacterTimerOut);

            iSubmitted = ETrue;

            }

        iHasNewTrace=EFalse; //Current stroke is ended,reset the flag.

        }

    else

        {

        //no new trace, no need to update the candidate content, just show it.

        if(!aCharacterTimerFlag)

            {

            ReportEvent(EEventHwrCharacterTimerOut);

            iSubmitted = ETrue;

            }

        }

    }

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

// CHwrWndBase::CancelCharWriting

// Cancel current drawing. Clears the stroke and stops the timer

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

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

//

EXPORT_C void CHwrWndBase::CancelCharWriting()

    {

    SetPointerDown(EFalse);

    //cancel timer

    iCharacterTimer->Cancel();

    iStrokeTimer->Cancel();            

    //reset the stroke

    ClearStroke();

    ReportEvent(EEventHwrStrokeCanceled);

    }

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

// CHwrWndBase::Draw

// Draw the window and stroke

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

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

//

EXPORT_C void CHwrWndBase::Draw()

    {

	if(!AbleToDraw())

        return;

    //draw back ground

    DrawBackground();

    DrawStroke(ETrue);

    }

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

// CHwrWndBase::DrawLine

// Draw a line

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

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

//   

TRect CHwrWndBase::DrawLine(const TPoint& aPt1,const TPoint& aPt2,TBool /*aDrawFlag*/)

    {

    //do nothing

    return TRect(aPt1,aPt2);

    }

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

// CHwrWndBase::HandlePointerDownEventL

// handle pointer down event

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

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

//    

EXPORT_C CFepUiBaseCtrl* CHwrWndBase::HandlePointerDownEventL( const TPoint& aPt)

    {

    CFepUiBaseCtrl::HandlePointerDownEventL(aPt);

    iPtPrev = aPt;

    iListOfPoints.AppendL(aPt- Rect().iTl);

    iStrokeTimer->Cancel();

    iCharacterTimer->Cancel();

    iHasNewTrace=ETrue;

    iSubmitted = EFalse;

    TRect rect;    

    rect = DrawPoint(aPt,ETrue);

    if(iDirtyRect.IsEmpty())

        iDirtyRect = rect;

    else

        {

        iDirtyRect.BoundingRect(rect);

        }

    UpdateArea(rect,EFalse);         

    ReportEvent(EEventHwrStrokeStarted);

    return this; 

    }

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

// CHwrWndBase::HanldePointerUpEventL

// handle pointer up event

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

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

//    

EXPORT_C CFepUiBaseCtrl* CHwrWndBase::HandlePointerUpEventL( const TPoint& aPoint)

    {

    iListOfPoints.AppendL(iStrokeEndMark);

    iStrokeTimer->SetTimer(iStrokeDelay);  

    CFepUiBaseCtrl::HandlePointerUpEventL(aPoint); 

    // iCtrlWithPointerDown of its CControlGroup must be set to NULL

    // when its up event occurs.

    CFepUiBaseCtrl* parent = ParentCtrl();

    while ( parent )

        {

        parent->CancelPointerDownL();

        parent = parent->ParentCtrl();

        }    

    return this;  

    }

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

// CHwrWndBase::HandleButtonMoveEventL

// Handle button move event

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

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

//

EXPORT_C CFepUiBaseCtrl* CHwrWndBase::HandlePointerMoveEventL(const TPoint& aPoint)

    {

    if(!PointerDown())

       return this;   

    iListOfPoints.AppendL(aPoint - Rect().iTl);     

    TRect rect=DrawLine(iPtPrev,aPoint,ETrue);

    /*if(!rect.IsEmpty())

        {

        TRect& drawrect = DirtyRect();

        drawrect.BoundingRect(rect); //find the bounding rect and set the rect

        }    */

    UpdateArea(rect,EFalse);         

    iPtPrev=aPoint;    

    return this;

    }

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

// CHwrWndBase::CancelPointerDownL

// Cancel the pointer down event in HWR window

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

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

//

void CHwrWndBase::CancelPointerDownL()

    {

    if( !PointerDown() )

        {

        return;

        }

	//allow pen up in other control. Do us normal pen up

	if( iListOfPoints.Count() > 0 )

        {

        iListOfPoints.AppendL(iStrokeEndMark);

        iStrokeTimer->SetTimer(iStrokeDelay);   

        }

	SetPointerDown(EFalse);

    CFepUiBaseCtrl::CancelPointerDownL();

    }

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

// CHwrWndBase::UpdateRegion

// Updates the area where other control made dirty

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

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

//     

void CHwrWndBase::UpdateRegion(CFepUiBaseCtrl* aCtrl)

    {

    if(aCtrl)

        {

        TRect rect;

        if(iDirtyRect.Intersects(aCtrl->Rect()))

            {

            DrawStroke(ETrue);

            rect.Intersection(iDirtyRect);

            UpdateArea(rect,EFalse);

            } 

        }    

    }

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

// CHwrWndBase::HandleTimerOut

// Handle timer out event.

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

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

//

EXPORT_C void CHwrWndBase::HandleTimerOut(TInt aTimeType)

    {

    switch(aTimeType)

        {

        case CLayoutTimer::ECharacterTimer:

            {

            TRAP_IGNORE(EndStrokeAndClearL());

            }

            break;

        case CLayoutTimer::EStrokeTimer:

            {

            TRAP_IGNORE(EndStrokeL(ETrue));

            }

            break;

        default:

            //Do nothing

            break;

        }

    }

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

// CHwrWndBase::ConstructL

// Symbian second phrase constructor

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

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

//

EXPORT_C void CHwrWndBase::ConstructL()

    {    

    BaseConstructL();

    iCharacterTimer = CLayoutTimer::NewL(this,CLayoutTimer::ECharacterTimer);

    iStrokeTimer = CLayoutTimer::NewL(this);    

    }

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

// CHwrWndBase::DrawStroke

// Draw stroke

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

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

//

EXPORT_C TRect CHwrWndBase::DrawStroke(TBool /*aDrawFlag*/)

    {

    //not implemented

    return TRect();

    }

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

// CHwrWndBase::EndStrokeAndClearL

// Called when character timer out. Not implemented, it's for derivated class.

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

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

//       

void CHwrWndBase::EndStrokeAndClearL()

    {

    EndStrokeL(EFalse);

    ClearStroke();

    } 

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

// CHwrWndBase::OnDeActivate

// Response to layout de activation event

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

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

//     

EXPORT_C void CHwrWndBase::OnDeActivate()

    {

    CFepUiBaseCtrl::OnDeActivate();

    iStrokeTimer->Cancel();

    iCharacterTimer->Cancel();

    }

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

// CHwrWndBase::OnLayoutDraggingStart

// Response to layout dragging start event

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

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

//     

EXPORT_C void CHwrWndBase::OnLayoutDraggingStart()

    {

    if ( iHasNewTrace )

        {

        ReportEvent(EEventHwrStrokeFinished);

        iHasNewTrace=EFalse;

        }

    iStrokeTimer->Cancel();

    if ( !iSubmitted )

        {

        ReportEvent(EEventHwrCharacterTimerOut);

        iSubmitted = ETrue;

        }

    iCharacterTimer->Cancel();

    iListOfPoints.Reset();                

    }

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

// CHwrWndBase::OnLayoutDraggingEnd

// Response to layout dragging end event

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

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

//     

EXPORT_C void CHwrWndBase::OnLayoutDraggingEnd()

    {

    }    

/******************** end of CHwrWndBase **********************************/

//class CTransparentHwrWnd

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

// CTransparentHwrWnd::CTransparentHwrWnd

// C++ default constructor

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

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

//

EXPORT_C CTransparentHwrWnd::CTransparentHwrWnd(const TRect& aRect,

                             CFepUiLayout* aUiLayout,TInt aCtrlId,

                             TBool aFullScreenFlag)

                            :CHwrWndBase(aRect,aUiLayout,aCtrlId),

                             iIsFullScreen(aFullScreenFlag),

                             iTraceOutsideWindowFlag(EFalse),

                             iTransparencyFactor(KDefaultTransparency)

    {

    SetControlType(ECtrlTransparentHwrWnd);

    const TRgb KDefaultMaskCol(200,200,200);

    if(iIsFullScreen)

        {

        SetMaskBkCol( TRgb(KTransparentColor)); //full transparent

        }

    else

        SetMaskBkCol(KDefaultMaskCol);

    SetBorderColor(TRgb(KOpaqueColor));

    //transparent window allow dragging on top of it

    SetAllowOverlap(ETrue);

    }

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

// CTransparentHwrWnd::~CTransparentHwrWnd

// Destructor

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

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

//

EXPORT_C CTransparentHwrWnd::~CTransparentHwrWnd()

    {

    if(iTraceOutsideWindowFlag)

        {

        TRAP_IGNORE(RequireRegionUpdateL(EFalse));

        }

    if ( iPenTraceDecorator )

        {

        delete iPenTraceDecorator;

        iPenTraceDecorator = NULL;

        }

    }

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

// CTransparentHwrWnd::NewL

// Factory function

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

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

//

EXPORT_C CTransparentHwrWnd* CTransparentHwrWnd::NewL(const TRect& aRect,

                                    CFepUiLayout* aUiLayout,TInt aCtrlId,

                                    TBool aFullScreenFlag)

    {

    CTransparentHwrWnd* wnd=new(ELeave) CTransparentHwrWnd(aRect,aUiLayout,

                                                        aCtrlId,aFullScreenFlag);

    CleanupStack::PushL(wnd);

    wnd->ConstructL ();

    CleanupStack::Pop(wnd);

    return wnd;

    }

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

// CTransparentHwrWnd::SetWndTransparencyFactor

// Set the transparency factor

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

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

//

void EXPORT_C CTransparentHwrWnd::SetWndTransparencyFactor(TUint8 aFactor)

    {

    if(iTransparencyFactor != aFactor)

        {

        //change mask col        

        TUint8 col = aFactor;

        SetMaskBkCol(TRgb( 255- col, 255 - col, 255 - col));     

        iTransparencyFactor = aFactor;

        Draw();

        UpdateArea(Rect(),ETrue);

        UiLayout()->LayoutOwner()->FlushUi();