/*

* 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 <peninputdropdownlist.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>

#include <coemain.h>

#include <peninputdragbutton.h>

#include <peninputrepeatbutton.h>

#include <peninputdataconverter.h>

#include <peninputpluginutils.h>

// User includes

#include "peninputlayoutchoicelist.h"

#include "peninputhwrarabicwindow.h"

#include "peninputhwrarabicdatamgr.h"

#include "peninputhwrarabic.hrh"

#include "peninputhwrarabicengine.h"

//#include "peninputhwrevent.h"

#include "peninputhwrarabiclayout.h"

// Constants

_LIT( KHwrWindowResourceFile, 

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

_LIT( KConfigurationResourceFile, 

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

_LIT( KResourceFileExtName, ".RSC" );

_LIT(KStandardPuncExclamatoryPoint, "\x0021");

_LIT(KStandardPuncDotPoint, "\x002E");

_LIT(KArabicPuncComma, "\x060C");

_LIT(KArabicPuncSemicolon, "\x061B");

_LIT(KArabicPuncQuestion, "\x061F");

_LIT(KArabicPuncWaw, "\x0648");

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 ========

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

// CPeninputHwrBxAbWnd::CPeninputHwrBxAbWnd

// (other items were commented in a header)

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

//

CPeninputHwrBxAbWnd::CPeninputHwrBxAbWnd( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    : CPeninputLayoutWindow( aUiLayout, aLayoutContext ),

      iNormalTransFactor(KNormalFactor),

      iWriteTransFactor(KWrittingFactor),

      iGuideLineSet(EFalse),

      iBackspaceMirrored(EFalse)

    {

    }

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

// CPeninputHwrBxAbWnd::NewL

// (other items were commented in a header)

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

//

CPeninputHwrBxAbWnd* CPeninputHwrBxAbWnd::NewL( 

    CFepUiLayout* aUiLayout, MPeninputLayoutContext* aLayoutContext )

    {

    CPeninputHwrBxAbWnd* self = 

        new ( ELeave ) CPeninputHwrBxAbWnd( aUiLayout, aLayoutContext );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPeninputHwrBxAbWnd::~CPeninputHwrBxAbWnd

// (other items were commented in a header)

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

//

CPeninputHwrBxAbWnd::~CPeninputHwrBxAbWnd()

    {

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

        {

        delete iRecogResult[i];

        }

    iRecogResult.Close();

    iStrokeArray.Close();

    delete iLastResult;

    delete iBmpRotator;

    }

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

// CPeninputHwrBxAbWnd::ConstructL

// (other items were commented in a header)

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

//

void CPeninputHwrBxAbWnd::ConstructL()

    {

    iBmpRotator = CPeninputSyncBitmapRotator::NewL();    

    CPeninputLayoutWindow::ConstructL();   

    CPeninputHwrBxAbDataMgr::THandWritingPenData* penData = 

        ( CPeninputHwrBxAbDataMgr::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);

        }

    }

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

// CPeninputHwrBxAbWnd::HandleControlEvent

// (other items were commented in a header)

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

//

void CPeninputHwrBxAbWnd::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:

            {

            CPeninputHwrBxAbDataMgr::THandWritingPenData* penData = 

                ( CPeninputHwrBxAbDataMgr::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:

            {

            CPeninputHwrBxAbDataMgr::THandWritingPenData* penData = 

                ( CPeninputHwrBxAbDataMgr::THandWritingPenData* ) 

                iLayoutContext->RequestData( EPeninputDataTypeReserve_1 );

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

            iHwBox->RefreshUI();

            }

            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);

                        }

                    }

                }

            else

                {// handle dropdownlist when user tapped switch inputmethods popup window without selecting other inputmethods.

                TInt dataType = CPeninputDataConverter::AnyToInt(iLayoutContext->RequestData( EPeninputDataTypeCurrentRange ));

                if (dataType == ERangeNative)

                    {

                    ResetAndShowDropdownList();

                    }

                else

                    {

                    ClearAndCloseDropdownList();

                    }

                }

            }

            break;

        case EPeninputLayoutEventToVkb:

            {

            iHwBox->CancelCharWriting();

            TInt curRange = CPeninputDataConverter::AnyToInt(iLayoutContext->RequestData(EPeninputDataTypeCurrentRange) );

            if (curRange == ERangeNative)

                {

                iDropdownList->ResetAndClear(CFepCtrlDropdownList::EListExpandableMultiRowWithoutIcon );

                }

            PopupSwitchWindow();

            }

            break; 

        case EPeninputLayoutEventRange:

            {

            iHwBox->CancelCharWriting();

            ClearAndCloseDropdownList();

            SizeChanged(ETrue);

            }

            break;

        case EPeninputLayoutEventBack:

            {

            HandleBackspaceKeyEvent();

            }

            break;

        default:

            break;

        }

    }

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

// CPeninputHwrBxAbWnd::GetWindowConfigResId

// (other items were commented in a header)

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

//

TInt CPeninputHwrBxAbWnd::GetWindowConfigResId()

    {

    return R_PENINPUT_LAYOUT_CONFIG_INFO;

    }

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

// CPeninputHwrBxAbWnd::GetWindowResId

// (other items were commented in a header)

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

//

TInt CPeninputHwrBxAbWnd::GetWindowResId()

    {

    return R_PENINPUT_LAYOUT_HWR_WINDOW;        

    }

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

// CPeninputHwrBxAbWnd::GetWindowConfigResFileName

// (other items were commented in a header)

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

//

const TDesC& CPeninputHwrBxAbWnd::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;

    }

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

// CPeninputHwrBxAbWnd::GetWindowResFileName

// (other items were commented in a header)

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

//

const TDesC& CPeninputHwrBxAbWnd::GetWindowResFileName()

    {

    return KHwrWindowResourceFile();

    }

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

// CPeninputHwrBxAbWnd::CreateAllControlsL

// (other items were commented in a header)

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

//

void CPeninputHwrBxAbWnd::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 );

    AddControlL( iModeSwitchChoice );    

    iModeSwitchChoice->AddEventObserver( UiLayout() );             

    //add dropdown list to client pane.

    TPixelsTwipsAndRotation ptSize;     

    CCoeEnv* coeEnv = CCoeEnv::Static();    

    coeEnv->ScreenDevice()->GetDefaultScreenSizeAndRotation(ptSize);

    TBool boxWndLandscape;

    //set proper screen style for box window

    if (ptSize.iPixelSize.iWidth < ptSize.iPixelSize.iHeight)

        {

        // protrait screen

        boxWndLandscape = EFalse;

        }

    else

        {

        // landscape screen

        boxWndLandscape = ETrue;

        }

    AddDropdownListL(boxWndLandscape);

//    TRect rect = iHwBox->Rect();

//    rect.iTl.iY = rect.iTl.iY + 2*iUnitHeight;

//    

//    iHwBox->SetRect(rect);

    if( iCtrlPool != NULL )

        {

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

            {

            if ( iCtrlPool->ControlByIndex( i ) )

                {

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

                }

            }

        }

    }

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

// CPeninputHwrBxAbWnd::ChangeUnitSize

// (other items were commented in a header)

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

//

const TRect CPeninputHwrBxAbWnd::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;

    }

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

// CPeninputHwrBxAbWnd::ChangeClientSize

// (other items were commented in a header)

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

//

void CPeninputHwrBxAbWnd::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() );

        }

    //mirror backspace arrow

    TRAP_IGNORE(MirrorBackspaceButtonResL());    

    }

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

// CPeninputHwrBxAbWnd::ReorganizeControls

// (other items were commented in a header)

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

//

void CPeninputHwrBxAbWnd::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();