/*

* Copyright (c) 2002-2005 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 of hwr window class

*

*/

// System includes

#include <peninputhwrwindow.rsg>

#include <peninputhwrwindowconfiginfo_01.rsg>

#include <aknfeppeninputenums.h>

#include <peninputinputcontextfield.h>

#include <peninputpluginutils.h>

#include <peninputcommonlayout.h>

#include <peninputeventbutton.h>

#include <peninputrepeatbutton.h>

#include <peninputlayouthwrwnd.h>

#include <peninputrangebar.h>

#include <peninputdataconverter.h>

#include <peninputdataprovider.h>

#include <peninputclientlayoutinfo.h>

#include <AknIconUtils.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsUtils.h>

#include <peninputlayoutchoicelist.h>

#include <AknFepGlobalEnums.h>

#include <peninputlayoutinputmodechoice.h>

#include <peninputlayoutmultilineicf.h>

// User includes

#include "peninputlayoutchoicelist.h"

#include "peninputgenerichwrwindow.h"

#include "peninputgenerichwrdatamgr.h"

#include "peninputgenerichwr.hrh"

#include "peninputgenericrecognizer.h"

#include "peninputgenerichwrlayout.h"

// Constants

_LIT( KHwrWindowResourceFile, 

      "z:\\resource\\plugins\\peninputhwrwindow.RSC" );

_LIT( KConfigurationResourceFile, 

      "z:\\resource\\plugins\\peninputhwrwindowconfiginfo_" );

_LIT( KResourceFileExtName, ".RSC" );

const TInt KWrittingFactor = 0;

const TInt KNormalFactor = 26;

const TInt KWriteBoxFrameBackColorMajor = EAknsMajorSkin;

const TInt KWriteBoxFrameBackColorGrp = EAknsMinorQsnOtherColors;

const TInt KWriteBoxFrameBackColorIdx = EAknsCIQsnOtherColorsCG9; 

const TUint32 KDefaultWriteBoxFrameColor = 0x000000;

const TUint32 KDefaultWriteBoxBackColor = 0xffffff;

const TInt KPeninputHwrWndInvalidIndex = -1;

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

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

// CPeninputGenericHwrWindow::CPeninputGenericHwrWindow

// (other items were commented in a header)

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

//

CPeninputGenericHwrWindow::CPeninputGenericHwrWindow( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    : CPeninputLayoutWindow( aUiLayout, aLayoutContext ),

      iNormalTransFactor(KNormalFactor),

      iWriteTransFactor(KWrittingFactor),

      iGuideLineSet(EFalse)

    {

    }

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

// CPeninputGenericHwrWindow::NewL

// (other items were commented in a header)

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

//

CPeninputGenericHwrWindow* CPeninputGenericHwrWindow::NewL( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    {

    CPeninputGenericHwrWindow* self = 

        new ( ELeave ) CPeninputGenericHwrWindow( aUiLayout, aLayoutContext );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPeninputGenericHwrWindow::~CPeninputGenericHwrWindow

// (other items were commented in a header)

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

//

CPeninputGenericHwrWindow::~CPeninputGenericHwrWindow()

    {

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

        {

        delete iRecogResult[i];

        }

    iRecogResult.Close();

    iStrokeArray.Close();

    delete iLastResult;

    }

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

// CPeninputGenericHwrWindow::ConstructL

// (other items were commented in a header)

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

//

void CPeninputGenericHwrWindow::ConstructL()

    {

    CPeninputLayoutWindow::ConstructL();   

    CPeninputGenericHwrDataMgr::THandWritingPenData* penData = 

        ( CPeninputGenericHwrDataMgr::THandWritingPenData* ) 

        iLayoutContext->RequestData( EPeninputDataTypeReserve_1 );

    if ( ( penData ) && ( iHwBox ) )

        {

        iHwBox->SetCharacterDelay( penData->iWritingSpeed );

        iHwBox->SetFadingSpeed(penData->iFadingSpeed);

#ifdef _NOT_USING_DECUMA_MCR_

        // similar as S90     

        iHwBox->SetStrokeDelay( 90000 );

#endif

        iHwBox->SetPenSize( penData->iPenSize );

        iHwBox->SetPenColor( penData->iPenColor );

        iHwBox->SetWndTransparencyFactor(iNormalTransFactor);

        }

    }

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

// CPeninputGenericHwrWindow::HandleControlEvent

// (other items were commented in a header)

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

//

void CPeninputGenericHwrWindow::HandleControlEvent( TInt aEventType,

                                                    CFepUiBaseCtrl* aCtrl, 

                                                    const TDesC& aEventData )

    {

    // Call this function in base class

    CPeninputLayoutWindow::HandleControlEvent( aEventType, 

                                               aCtrl, 

                                               aEventData );

    TInt* data = ( TInt* ) aEventData.Ptr(); 

    switch ( aEventType )

        {

        case EPeninputLayoutHwrEventPenColorChange:

        case EPeninputLayoutHwrEventPenSizeChange:

        case EPeninputLayoutHwrEventWritingSpeedChange:

            {

            CPeninputGenericHwrDataMgr::THandWritingPenData* penData = 

                ( CPeninputGenericHwrDataMgr::THandWritingPenData* ) 

                iLayoutContext->RequestData( EPeninputDataTypeReserve_1 );

            iHwBox->SetCharacterDelay( penData->iWritingSpeed );

            iHwBox->SetFadingSpeed(penData->iFadingSpeed);

#ifdef _NOT_USING_DECUMA_MCR_

            // similar as S90                 

            iHwBox->SetStrokeDelay( 90000 );

#endif

            iHwBox->SetPenSize( penData->iPenSize );

            iHwBox->SetPenColor( penData->iPenColor );

            }

            break;

        case EPeninputLayoutHwrEventGuideLineChanged:

            {

            CPeninputGenericHwrDataMgr::THandWritingPenData* penData = 

                ( CPeninputGenericHwrDataMgr::THandWritingPenData* ) 

                iLayoutContext->RequestData( EPeninputDataTypeReserve_1 );

            iHwBox->HideGuideLine( penData->iGuideLineOn == 0 ? EFalse : ETrue );

            iHwBox->RefreshUI();

            }

            break;

        case EEventHwrStrokeStarted:

            {

            OnStrokeStarted();

            }

            break;

        case EEventHwrStrokeFinished:

            {

            OnStrokeFinished();

            }

            break;

        case EEventHwrCharacterTimerOut:

            {

            OnStrokeCharacterTimerOut();

            }

            break;

        case EEventHwrStrokeCanceled:

            {

            OnStrokeCanceled();

            }

            break;  

        case EPeninputLayoutEventCloseWindow:

            {

            iStrokeArray.Reset();

            iHwBox->CapturePointer(EFalse);

            iHwBox->CancelCharWriting();

            }

            break;        

        case EEventChoiceSelected:

            {

            CFepLayoutChoiceList::SEvent* event = 

                ( CFepLayoutChoiceList::SEvent* ) aEventData.Ptr();

            if ( event->iIndex != KPeninputHwrWndInvalidIndex )

                {

                if (aCtrl->ControlId() == EPeninutWindowCtrlIdSwitcherPopupWindow)

                    {

                    if (EPluginInputModeHwr != event->iCommand)

                        {

                        TBool switchByMode = ETrue;

                        TInt  mode = event->iCommand;

                        TBuf<8> buf;

                        buf.Append(reinterpret_cast<TText*>(&switchByMode), 

                                   sizeof(TBool)/sizeof(TText));

                        buf.Append(reinterpret_cast<TText*>(&mode), sizeof(TInt)/sizeof(TText));

                        UiLayout()->SignalOwner(ESignalLayoutUIChanged,buf);

                        }

                    }

                }

            }

            break;

        case EPeninputLayoutEventToVkb:

            {

            iHwBox->CancelCharWriting();

            PopupSwitchWindow();

            }

            break; 

        default:

            break;

        }

    }

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

// CPeninputGenericHwrWindow::GetWindowConfigResId

// (other items were commented in a header)

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

//

TInt CPeninputGenericHwrWindow::GetWindowConfigResId()

    {

    return R_PENINPUT_LAYOUT_CONFIG_INFO;

    }

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

// CPeninputGenericHwrWindow::GetWindowResId

// (other items were commented in a header)

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

//

TInt CPeninputGenericHwrWindow::GetWindowResId()

    {

    return R_PENINPUT_LAYOUT_HWR_WINDOW;        

    }

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

// CPeninputGenericHwrWindow::GetWindowConfigResFileName

// (other items were commented in a header)

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

//

const TDesC& CPeninputGenericHwrWindow::GetWindowConfigResFileName( 

    TInt aLangID )

    {

    if ( aLangID <= 0 ) 

        {

        return KNullDesC;

        }

    iResourceFilename.Zero();

    iResourceFilename = KConfigurationResourceFile();

    if ( aLangID < 10 )

        {

         iResourceFilename.AppendNum( 0 );

         iResourceFilename.AppendNum( aLangID );

        }

    else

        {

         iResourceFilename.AppendNum( aLangID );

        }

    iResourceFilename.Append( KResourceFileExtName );

    return iResourceFilename;

    }

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

// CPeninputGenericHwrWindow::GetWindowResFileName

// (other items were commented in a header)

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

//

const TDesC& CPeninputGenericHwrWindow::GetWindowResFileName()

    {

    return KHwrWindowResourceFile();

    }

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

// CPeninputGenericHwrWindow::CreateAllControlsL

// (other items were commented in a header)

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

//

void CPeninputGenericHwrWindow::CreateAllControlsL()

    {

    // Hwr box    

    AddHwBoxL();

    // Range bar

    AddRangeBarL();

    // Language switch button

    iLangSwitchBtn = AddButtonL( EPeninutWindowCtrlIdInputLangSwitcherBtn, 

                                 EPeninputLayoutEventSwitchLanguage, 

                                 R_PENINPUT_LAYOUT_HWR_SWITCH ); 

    SetSwitchBtnFont(*iLangSwitchBtn);

    SetSwitchBtnTextColor(*iLangSwitchBtn);

    // Switch to vkb button

    AddButtonL( EPeninutWindowCtrlIdSwitchToVkbBtn, 

                EPeninputLayoutEventToVkb, 

                R_PENINPUT_LAYOUT_HWR_VKB );

    iModeSwitchChoice = CPeninputLayoutInputmodelChoice::NewL( UiLayout(),

            EPeninutWindowCtrlIdSwitcherPopupWindow, EPluginInputModeHwr);

    iModeSwitchChoice->SetListSkinID( KAknsIIDQsnFrList, KAknsIIDQsnFrPopupSub );

    iModeSwitchChoice->AddEventObserver( UiLayout() );             

    AddControlL( iModeSwitchChoice );

    if( iCtrlPool != NULL )

        {

        for ( TInt i = 0; i < iCtrlPool->ControlCount(); i++ )

            {

            iCtrlPool->ControlByIndex( i )->AddEventObserver( UiLayout() );

            }

        }

    }

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

// CPeninputGenericHwrWindow::ChangeUnitSize

// (other items were commented in a header)

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

//

const TRect CPeninputGenericHwrWindow::ChangeUnitSize()

    {

    if (CPeninputDataConverter::AnyToInt(

                                   iLayoutContext->RequestData(EAkninputDataTypeSizeChanging)) ||

        !(CPeninputDataConverter::AnyToInt(

                                   iLayoutContext->RequestData(EAkninputDataTypeUnitSizeSet))))

        {

        // if size changing, or unitwidth, unitheight has not been set yet

        TAknWindowLineLayout appWnd;

        TAknWindowLineLayout mainPane;

        TAknWindowLineLayout wndLayout;

        TAknWindowLineLayout unitLayout;

        TAknLayoutRect mainPaneRect;

        TAknLayoutRect wndRect;

        TAknLayoutRect unitRect;

        // Get hwr window layout

        appWnd = AknLayoutScalable_Avkon::application_window( 0 ).LayoutLine();

        if (appWnd.iW > appWnd.iH)

            {

    	      // landscape

    	      mainPane = AknLayoutScalable_Avkon::main_pane(4).LayoutLine();

            wndLayout = AknLayoutScalable_Avkon::popup_fep_hwr_window(2).LayoutLine();

            }

        else

            {

            // portrait	

            mainPane = AknLayoutScalable_Avkon::main_pane(1).LayoutLine();

            wndLayout = AknLayoutScalable_Avkon::popup_fep_hwr_window(0).LayoutLine();

            }

        mainPaneRect.LayoutRect(appWnd.Rect(), mainPane);

        wndRect.LayoutRect(mainPaneRect.Rect(), wndLayout);

        unitLayout = AknLayoutScalable_Avkon::fep_hwr_aid_pane(1).LayoutLine();

        unitRect.LayoutRect(wndRect.Rect(), unitLayout);

        iHwrWndRect = TRect(0,

                            0,

                            wndRect.Rect().Width(),

                            wndRect.Rect().Height());

        TInt unitWidth = unitRect.Rect().Width();

        TInt unitHeight = unitRect.Rect().Height();

        iLayoutContext->SetData(EPeninputDataTypeUnitWidth, &unitWidth);

        iLayoutContext->SetData(EPeninputDataTypeUnitHeight, &unitHeight);

        }

    return iHwrWndRect;

    }

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

// CPeninputGenericHwrWindow::ChangeClientSize

// (other items were commented in a header)

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

//

void CPeninputGenericHwrWindow::ChangeClientSize()

    {

    TInt unitWidth = CPeninputDataConverter::AnyToInt

        ( iLayoutContext->RequestData( EPeninputDataTypeUnitWidth ) );

    TInt unitHeight = CPeninputDataConverter::AnyToInt

        ( iLayoutContext->RequestData( EPeninputDataTypeUnitHeight ) );   

    // Modify language switch button font

    SetSwitchBtnFont(*iLangSwitchBtn);

    TInt clientLayoutId = CPeninputDataConverter::AnyToInt

        ( iLayoutContext->RequestData( EPeninputDataTypeClientLayout ) );

    CPeninputClientLayoutInfo* clientLayout = 

        ConfigInfo()->FindClientLayoutInfo( clientLayoutId );

    if ( clientLayout )

        {

        // Change self rect

        /*TInt width = clientLayout->Columns() * unitWidth;

        TInt height = clientLayout->Rows() * unitHeight;

        TRect rect = TRect( ClientPane()->Rect().iTl, 

                            TSize( width, height ) );

        ClientPane()->SetRect( rect );*/

        // Change the postion and size of controls in current layout

        ReorganizeControls( clientLayout->LayoutID() );

        }

    }

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

// CPeninputGenericHwrWindow::ReorganizeControls

// (other items were commented in a header)

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

//

void CPeninputGenericHwrWindow::ReorganizeControls( TInt aClientLayoutId, TBool /*aNeedReset*/ )

    {

    TInt unitWidth = CPeninputDataConverter::AnyToInt

        ( iLayoutContext->RequestData( EPeninputDataTypeUnitWidth ) );

    TInt unitHeight = CPeninputDataConverter::AnyToInt

        ( iLayoutContext->RequestData( EPeninputDataTypeUnitHeight ) );

    CPeninputClientLayoutInfo* clientLayout = 

                ConfigInfo()->FindClientLayoutInfo( aClientLayoutId );

    // First remove all controls in the client pane, but don't delete them

    ( const_cast<RPointerArray<CFepUiBaseCtrl>&>

        ( ClientPane()->ControlList() ) ).Reset();

    // Set case sensitive for the engine

    CPeninputGenericHwrDataMgr::THandWritingPenData* penData = 

        ( CPeninputGenericHwrDataMgr::THandWritingPenData* ) 

        iLayoutContext->RequestData( EPeninputDataTypeReserve_1 );

    penData->iRecognizer->SetCaseSensitive( ConfigInfo()->CaseSensitive() );

    //Set guideline on or off

    penData->iRecognizer->EnableGuideline( penData->iGuideLineOn == 1? ETrue : EFalse );

    //reset window rect, titlebar rect, client rect

    TSize szClient( clientLayout->Columns() * unitWidth, 

                    clientLayout->Rows() * unitHeight );

    TSize szWnd( clientLayout->Columns() * unitWidth, 

                 clientLayout->Rows() * unitHeight + unitHeight );                       

    TSize szTitle ( clientLayout->Columns() * unitWidth, unitHeight );

    SetWindowRect( TRect(Rect().iTl, szWnd) ); 

    //setwindowrect may change automactially for shadow or other things

    TPoint ptTopLeft = Rect().iTl;

    TitleBar()->SetRect( TRect(ptTopLeft, szTitle ) );

    ClientPane()->SetRect( TRect(ptTopLeft + TPoint(0, unitHeight),

                               szClient) );

    // Get control list from client layout

    RPointerArray<CPeninputControlInfo>& controlList = 

        clientLayout->ControlInfoList();

    const TInt count = controlList.Count();

    TInt controlID = 0;

    TInt cols = 0;

    TInt rows = 0;

    CFepUiBaseCtrl* ctrl = NULL;

    //controls are based on client pane

    TPoint point = ptTopLeft + TPoint(0, unitHeight);

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

        {

        controlID = controlList[i]->ControlID();

        ctrl = iCtrlPool->Control( controlID );

        if ( ctrl )

            {

            TRect rect;

            rect.iTl = point 

                + TPoint( controlList[i]->BeginColumn() * unitWidth, 

                          controlList[i]->BeginRow() * unitHeight );

            cols = controlList[i]->EndColumn() 

                - controlList[i]->BeginColumn();

            rows = controlList[i]->EndRow() 

                - controlList[i]->BeginRow();

            rect.SetSize( TSize( cols * unitWidth, rows * unitHeight ) ); 

            AddNotOwnedControl( ctrl );

            if ( ( ctrl->ControlType() | ECtrlButton ) == ECtrlButton )

                {