/*

* 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:  Implement of class CTruiHwrBox

*

*/

// INCLUDE FILES

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknUtils.h>

#include <AknsSkinInstance.h>

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsConstants.h>

#include <trui_icons.mbg>

#include "truihwrbox.h"

#include "truihwrboxobserver.h"

#include "truiappui.h"

#include "truiappui.h"

#include "truiengine.h"

#ifdef __WINS__

static const TInt KWritePeriod = 1500000;

#else

static const TInt KWritePeriod = 1000000;

#endif

#ifdef __WINS__

static const TInt KDrawSpeed = 30000;

#else

static const TInt KDrawSpeed = 30000;

#endif

const TInt KFirstPoint = -1;

const TSize KGuideLinePenSize = TSize( 1, 1 );

const TSize KLinePenSize = TSize( 4, 4 );

const TInt KFirstEventDelay = 0;

_LIT( KTRUIICONSFILENAME, "\\resource\\apps\\trui_icons.mif" );

const TInt KTopGuideLineIndex = 0;

const TInt KBottomGuideLineIndex = 1;

const TInt KGuideLineWidthRadio = 10;

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

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

// Two-phased constructor.

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

//

CTruiHwrBox* CTruiHwrBox::NewL( CCoeControl* aParent,

                                MTruiHwrBoxObserver* aHwrBoxObserver,

                                MAknsControlContext* aBgContext )

    {

    CTruiHwrBox* self = CTruiHwrBox::NewLC( aParent, aHwrBoxObserver,

                                            aBgContext );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CTruiHwrBox* CTruiHwrBox::NewLC( CCoeControl* aParent,

                                 MTruiHwrBoxObserver* aHwrBoxObserver,

                                 MAknsControlContext* aBgContex )

    {

    CTruiHwrBox* self = new ( ELeave ) CTruiHwrBox();

    CleanupStack::PushL( self );

    self->ConstructL( aParent, aHwrBoxObserver,

                      aBgContex );

    return self;

    }

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

// CTruiHwrBox::CTruiHwrBox()

// C++ default constructor can NOT contain any code, that might leave.

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

//

CTruiHwrBox::CTruiHwrBox()

    {

    // No implementation required

    }

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

// CTruiHwrBox::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CTruiHwrBox::ConstructL( CCoeControl* aParent,

                              MTruiHwrBoxObserver* aHwrBoxObserver,

                              MAknsControlContext* aBgContext )

    {

    if ( aParent ) 

        {

        SetContainerWindowL( *aParent );

        }

    else

        {

        CreateWindowL();

        }

    SetHwrBoxObserver( aHwrBoxObserver );

    // Create tooltip

    iTooltip = CAknInfoPopupNoteController::NewL();    

    iTooltip->SetTooltipModeL( ETrue );

    iTooltip->AddObserverL( *this );

    iBoxState = ENewModelStop;    

    iTimeToSave = CPeriodic::NewL( CActive::EPriorityHigh ); // neutral priority

    iTimeToDrawNext = CPeriodic::NewL( CActive::EPriorityStandard ); // neutral priority

    iPointArrayDraw.Reset();

    iPointArrayModel.Reset();

    LoadBorderBitmapsL();

    LoadShadowBitmapsL();

    LoadGuideLineBitmapsL();

    EnableDragEvents();    

    iBgContext = static_cast<CAknsBasicBackgroundControlContext*>( aBgContext );

    }

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

// CTruiHwrBox::~CTruiHwrBox()

// Destructor.

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

//

CTruiHwrBox::~CTruiHwrBox()

    {

    if ( iTooltip )

        {

        iTooltip->RemoveObserver( *this );

        }    

    HideInfoPopupNote();

    // Cancel and delete timer.

    if ( iTimeToSave )

        {

        iTimeToSave->Cancel();

        delete iTimeToSave;

        }

    if ( iTimeToDrawNext )

        {

        iTimeToDrawNext->Cancel();

        delete iTimeToDrawNext;

        }

    iPointArrayDraw.Close();

    iPointArrayModel.Close();

    delete iTooltip;

    iBorderBitmaps.ResetAndDestroy();

    iBorderBitmapMasks.ResetAndDestroy();

    iBorderLayout.Close();

    iShadowBitmaps.ResetAndDestroy();

    iShadowBitmapMasks.ResetAndDestroy();

    iShadowLayout.Close();

    iGuideLineBitmaps.ResetAndDestroy();

    iGuideLineBitmapMasks.ResetAndDestroy();

    iGuideLineLayout.Close();

    }

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

// Draws control to given area

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

//

void CTruiHwrBox::Draw( const TRect& /*aRect*/ ) const

    {

    // Get the standard graphics context 

    CWindowGc& gc = SystemGc();        

    // Set context

    PrepareContext( gc );

    // Gets the control's extent

    TRect rect = Rect();

    if ( iBgContext )

        {

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        if ( !AknsDrawUtils::Background( skin, iBgContext, 

                                         gc, rect ) ) 

            {

            gc.Clear( rect );

            }

        }

    if ( iFlag & EFrameHwrBox == EFrameHwrBox )

        {

        // Draw border

        DrawBorders( gc );

        // Draw shawdow

        DrawShadows( gc ); 

        }

    // Get repository

    CRepository* repository = NULL;

    TRAPD( err, repository = CRepository::NewL( KCRUidPersonalizationSettings ) );

    if ( err == KErrNone )

        {

        TInt guideLine;

        repository->Get( KSettingsPenInputGuideLine, guideLine );

        delete repository;

        repository = NULL;

        // Draw guideline

        if ( guideLine )

            {

            // Draw guidelines            

            DrawGuideLines( gc );   

            }        

        }        

    // Draw work area  

    gc.SetPenSize( KLinePenSize );

    DrawTrails( gc );

    }

TInt CTruiHwrBox::TimeToSaveL( TAny* aObject )

    {

    ( (CTruiHwrBox*)aObject )->SaveModelL(); // cast, and call non-static function

    return KErrNone;

    }

TInt CTruiHwrBox::TimeToDrawNextL( TAny* aObject )

    {

    ( (CTruiHwrBox*)aObject )->DrawNextL(); // cast, and call non-static function

    return KErrNone;

    }

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

// CTruiHwrBox::TimedOut()

// Timer control, called everytime the time times out.

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

//

void CTruiHwrBox::SaveModelL()

    {

    if ( iBoxState == ENewModelDraw )

        {

        // Restore all screen to invalid region.

        Window().Invalidate();

        //Cancel the timer

        iTimeToSave->Cancel();

        iBoxState = EExistModelStop;

        SetPointerCapture( EFalse );

        iPointArrayModel.Reset();

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

            {

            iPointArrayModel.Append( iPointArrayDraw[i] );

            }

        //can't save an empty model

        if ( iPointArrayModel.Count() > 0 )

            {                        

            if ( iHwrBoxObserver )

                {

                iHwrBoxObserver->SaveNewModelL();

                }            

            }

        else

            {

            ClearExistModel();

            }

        iStartSave = EFalse;

        }

    }

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

// Compare the numbers of points of two arrays at first. if they are not same, 

// add a new point from iPointArrayModel to iPointArrayDraw. then draw a new line

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

//

void CTruiHwrBox::DrawNextL()

    {

    // Check HwrBox state at first and then Check if model is drawn acompletely

    if ( iBoxState == EExistModelDraw &&

        iPointArrayModel.Count() > iPointArrayDraw.Count() )

        {

        // Add new point to iPointArrayDraw

        iPointArrayDraw.AppendL( iPointArrayModel[ iPointArrayDraw.Count() ] );

        // Update the screen

        DrawModel();

        }

    else

        {

        iBoxState = EExistModelStop;

        iTimeToDrawNext->Cancel();

        Window().Invalidate();

        }

    }

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

// Draw an existing model

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

//

void CTruiHwrBox::PlayAnimation( TBool aIsScale, const TSize& aRefSize )

    {

    if ( ( iBoxState == EExistModelStop || iBoxState == EExistModelDraw ) 

        && iPointArrayModel.Count() )

        {

        // Check and scale model points         

        if ( aIsScale )

            {

            // Scale model points

            ScaleModel( aRefSize, Rect().Size(), iPointArrayModel );

            }

        //Cancel the timer at first

        iTimeToDrawNext->Cancel();

        //Clear the box

        iPointArrayDraw.Reset();

        if ( Parent() )

            {            

            Parent()->DrawNow();            

            }        

        //Set index of point need to be drawn to the beginning

        iLastAnimatedPoint = KFirstPoint;

        //Set animate timer

        iTimeToDrawNext->Start( KFirstEventDelay, KDrawSpeed, TCallBack( TimeToDrawNextL, this ) );

        //Change box state

        iBoxState = EExistModelDraw;

        }

    }

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

// Clear the existing model

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

//

void CTruiHwrBox::ClearExistModel()

    {

    switch ( iBoxState )

        {

        case EExistModelDraw:

            {

            //animation is playing, cancel the timer before clear it

            iTimeToDrawNext->Cancel();

            break;

            }

        case ENewModelDraw:

            {

            //new model is inputting, cancel the timer before clear it

            iTimeToSave->Cancel();

            iStartSave = EFalse;

            break;

            }

        case EExistModelStop:

        case ENewModelStop:

        default:

            {

            }

        }

    iPointArrayModel.Reset();

    iPointArrayDraw.Reset();

    iBoxState = ENewModelStop;

    Window().Invalidate();

    }

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

// Handles an event from an observed control.

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

//

void CTruiHwrBox::HandlePointerEventL( const TPointerEvent& aPointerEvent )

    {        

    if ( iFlag & EReadOnlyHwrBox )

        {

        // Readonly, don't handle pointer event.

        return;

        }

    CCoeControl::HandlePointerEventL( aPointerEvent );    

    if ( AknLayoutUtils::PenEnabled() )

        {

        switch( aPointerEvent.iType )

            {

            case TPointerEvent::EButton1Down:

                {

                Window().Invalidate();

                if ( IsContained( aPointerEvent.iPosition ) )

                    {   

                    HideInfoPopupNote();                 

                    iPenInRect = ETrue;

                    if ( iBoxState == ENewModelStop )

                        {

                        //change box state

                        iBoxState = ENewModelDraw;

                        SetPointerCapture( ETrue );

                        //start from the point where button is down

                        iPointArrayDraw.Append( aPointerEvent.iPosition - Position() );

                        iLastAnimatedPoint = KFirstPoint;

                        DrawModel();

                        }

                    else if ( iBoxState == ENewModelDraw )

                        {

                        //cancel the iTimeToSave

                        iTimeToSave->Cancel();

                        iStartSave = EFalse;

                        //start from the point where button is down

                        iPointArrayDraw.Append( aPointerEvent.iPosition - Position() );

                        DrawModel();

                        }

                    else

                        {

                        if ( iHwrBoxObserver )

                            {

                            iHwrBoxObserver->HandleEventL( MTruiHwrBoxObserver::EModelExist );

                            }                        

                        }

                    }

                else

                    {

                    iPenInRect = EFalse;

                    }

                break;    

                }

            case TPointerEvent::EButton1Up:    

                {                

                if ( iBoxState == ENewModelDraw )

                    {

                    iPointArrayDraw.Append( KTail ); 

                    if ( !iStartSave )

                        {

                        iStartSave = ETrue;

                        iTimeToSave->Start( KWritePeriod,

                                            KWritePeriod,

                                            TCallBack( TimeToSaveL, this ) );

                        }

                    }

                break;

                }

            case TPointerEvent::EDrag:

            case TPointerEvent::EMove:

                {

                if ( iBoxState == ENewModelDraw )

                    {                    

                    if ( IsContained( aPointerEvent.iPosition ) )

                        {

                        Window().Invalidate();

                        HideInfoPopupNote(); 

                        //Pen go into available rect again, start an new trace

                        if ( iPenInRect == EFalse )

                            {

                            iTimeToSave->Cancel();

                            iStartSave = EFalse;

                            }

                        iPointArrayDraw.Append( aPointerEvent.iPosition - Position() );

                        DrawModel();

                        iPenInRect = ETrue;

                        }

                    else

                        {

                        if ( iPenInRect )

                            {

                            iPointArrayDraw.Append( KTail );                           

                            if ( !iStartSave )

                                {

                                iStartSave = ETrue;

                                iTimeToSave->Start( KWritePeriod,

                                                    KWritePeriod,

                                                    TCallBack( TimeToSaveL, 

                                                               this ) );

                                }

                            iPenInRect = EFalse;

                            }

                        }

                    }

                break;

                }

            default:

                break;

            }

        }

    }

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

// Handles an event from an observed control.

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

//

TKeyResponse CTruiHwrBox::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/,

                                                TEventCode /*aType*/ )

    {

    return EKeyWasConsumed;

    }

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

// CTruiHwrBox::SetHwrBoxObserver

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

//

void CTruiHwrBox::SetHwrBoxObserver( MTruiHwrBoxObserver* aHwrBoxObserver )

    {

    iHwrBoxObserver = aHwrBoxObserver;

    }

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

// Get the HwrBox's model.

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

//

RArray<TPoint>& CTruiHwrBox::Model()

    {

    return iPointArrayModel;

    }

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