/*

* Copyright (c) 2005-2007 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 CFepUiLayout

*

*/

#include <w32std.h>

#include <s32mem.h>

#include <peninputcmd.h>

#include "peninputcmdparamext.h"

#include "peninputlayout.h"

#include "peninputlayoutbutton.h"

#include "peninputlayoutrootctrl.h"

#include <aknfeppeninputenums.h>

#include <AknDef.h>

#include <AknsConstants.h>

#include <coemain.h>

#include <AknsUtils.h> 

#include <AknsSkinInstance.h> 

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#include <featmgr.h>

#endif //RD_TACTILE_FEEDBACK

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

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

// CFepUiLayout::CFepUiLayout

// Constructor

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

//

EXPORT_C CFepUiLayout::CFepUiLayout(MLayoutOwner* aLayoutOwner)

                           :iLayoutOwner(aLayoutOwner),

                           iDragbarNum(0),iLockedArea(TRect(0,0,0,0)),

                           iLayoutReady(EFalse)

    {

    TPixelsTwipsAndRotation ptSize;             

    CCoeEnv::Static()->ScreenDevice()->

                            GetDefaultScreenSizeAndRotation(ptSize);

    //set the screen size in case any one need use it.                            

    iScreenSize = ptSize.iPixelSize;  

    }

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

// CFepUiLayout::~CFepUiLayout

// Destructor

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

//

EXPORT_C CFepUiLayout::~CFepUiLayout()

    {

#ifdef RD_TACTILE_FEEDBACK                  

    //remove all registered area

    SignalOwner(ESignalDeRegisterAllFeedbackArea);

#endif // RD_TACTILE_FEEDBACK 

    delete iRootCtrl;   

    delete iExtension;

    } 

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

// CFepUiLayout::BaseConstructL

// Do basic contructor

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

//

EXPORT_C void CFepUiLayout::BaseConstructL()

    {

    iRootCtrl = CFepUiLayoutRootCtrl::NewL(this);

    __ASSERT_DEBUG(iLayoutOwner,User::Leave(EUiLayoutNotReady));  

    iExtension = new(ELeave) CFepUiLayoutExt;

#ifdef RD_TACTILE_FEEDBACK

    iExtension->iTactileSupported = EFalse;

#endif // RD_TACTILE_FEEDBACK

    iExtension->iSkinInstance = AknsUtils::SkinInstance();

    iExtension->iTouchFeedbackInstance = MTouchFeedback::Instance();

	iExtension->iDisableDrawing = EFalse;

    }

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

// CFepUiLayout::HandleEventL

// handle event from window server

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

//

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

    {   

    TRawEvent event=*(static_cast<const TRawEvent*>(aData));

    if(ERawEvent == aType)

        {

        //handle raw key event

        if(TRawEvent::EKeyUp == event.Type() || TRawEvent::EKeyDown == event.Type())

            {            

            return HandleRawKeyEventL(event);

            }

        else

            {

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

                {

                if(!iRootCtrl->CtrlCapPointer() && 

                   !LayoutOwner()->LayoutRect().Contains(event.Pos()))

                    {

                    //point outside of ui layout

                    OnPointerEventOutsideLayout(event);

                    return EFalse;

                    } 

                }

            }

        }

    TBool handled = iRootCtrl->HandleEventL(aType,aData);   

    return handled;    

    }

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

// CFepUiLayout::SendEditorTextAndCursorPosL

// handle layout command

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

//

void CFepUiLayout::SendEditorTextAndCursorPosL(TUint8* aData)

    {

    RDesReadStream readStream;

    TPtr8 countPtr( aData, 2*sizeof(TInt), 2*sizeof(TInt) );            

	readStream.Open(countPtr);

	CleanupClosePushL(readStream);

    const TInt dataCount = readStream.ReadInt32L();

	const TInt textCount = readStream.ReadInt32L();

    CleanupStack::PopAndDestroy(&readStream);

    TPtr8 ptr( aData+2*sizeof(TInt), dataCount+textCount, dataCount+textCount );            

	readStream.Open(ptr);

	CleanupClosePushL(readStream);

	HBufC8* dataBuf = HBufC8::NewLC(dataCount);

	TPtr8 dataBufPtr = dataBuf->Des();

	readStream.ReadL(dataBufPtr, dataCount);

    TFepInputContextFieldData* pIcfData = 

        reinterpret_cast<TFepInputContextFieldData*>(const_cast<TUint8*>(dataBufPtr.Ptr()));

    HBufC8* textBuf = HBufC8::NewLC(textCount);

	TPtr8 textBufPtr = textBuf->Des();

	readStream.ReadL(textBufPtr, textCount);

    pIcfData->iText.Set( reinterpret_cast<const TUint16*>(textBufPtr.Ptr()),

                         textCount/2);

    OnAppEditorTextComing(*pIcfData);

    CleanupStack::PopAndDestroy(textBuf);

    CleanupStack::PopAndDestroy(dataBuf);

	CleanupStack::PopAndDestroy(&readStream);

    }

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

// CFepUiLayout::HandleCommand

// handle layout command

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

//

EXPORT_C TInt CFepUiLayout::HandleCommand(TInt aCmd, TUint8* aData)

    { 

    TInt ret = KErrNone;

    switch( aCmd )

        {

        case ECmdPenInputSendEditorTextAndCurPos:

            {

            TRAP_IGNORE(SendEditorTextAndCursorPosL(aData));

            }

            break;

        case ECmdPeninputEnableOwnBitmap:

            {

            SetSelfBmpDeviceFlag(*(reinterpret_cast<TBool*>(aData)));

            OnResourceChange(KPenInputOwnDeviceChange);

            }

            break;

        case ECmdPeninputDisableLayoutDrawing:

            {

            DisableLayoutDrawing(*(reinterpret_cast<TBool*>(aData)));

            }

            break;

        default: 

            {

            ret = -1;

            }	

            break;

        }

    return ret;

    }

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

// CFepUiLayout::InitL

// Initialize the layout

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

//

EXPORT_C TRect CFepUiLayout::Init()

    {

    //Init control    

    TRect r = iRootCtrl->InitControl();

    r.Move( Position() );

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

        {

        iDragbarList[i]->AddPositionObserver(static_cast<MPositionObserver*>

                                                                (iRootCtrl)); 

        }

    //iLayoutReady = ETrue;

    return r;

    }

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

// CFepUiLayout::AddControlL

// Add a control to layout

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

//

EXPORT_C void CFepUiLayout::AddControlL(CFepUiBaseCtrl* aControl,

                                                    TBool aEventObserverFlag)

    {

    if(!aControl)

        return;

    iRootCtrl->AddControlL(aControl);

    //add event observer

    if(aEventObserverFlag)

        aControl->AddEventObserver(this);

    }

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

// CFepUiLayout::AddControlL

// Add a control to layout

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

//

EXPORT_C void CFepUiLayout::AddControlL(CCoeControl* aControl,

                                                    TBool aEventObserverFlag)

    {

    if(!aControl)

        return;

    CFepUiBaseCtrl* ctrl = iRootCtrl->AddControlL(aControl);

    //add event observer

    if(aEventObserverFlag && ctrl)

        ctrl->AddEventObserver(this);

    }

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

// CFepUiLayout::RemoveControl

// Remove a control to layout

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

//

EXPORT_C void CFepUiLayout::RemoveControl(CFepUiBaseCtrl* aControl)

    {    

    if(!aControl)

        return;

    //check whether the control is a dragbar

    if(aControl->IsKindOfControl(ECtrlDragBar))

        {

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

            {

            if(aControl == iDragbarList[i])

                {

                iDragbarNum --;

                for(TInt j = i+1; j < iDragbarNum; j++)

                    {                    

                    iDragbarList[j-1] = iDragbarList[j];

                    }

                break;

                }                

            }

        }

    //Remove from event list

    if(aControl)

        aControl->RemoveEventObserver(this);        

    //remove control        

    iRootCtrl->RemoveControl(aControl);    

    //aControl is deleted, so reset the pointer.

    aControl = 0;

    }

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

// CFepUiLayout::Draw

// Draw layout

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

//

EXPORT_C void CFepUiLayout::Draw()

    {

    iRootCtrl->Draw();

    }

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

// CFepUiLayout::HandleRawKeyEventL

// Handle key event

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

//

EXPORT_C TBool CFepUiLayout::HandleRawKeyEventL(const TRawEvent& /*aKeyEvent*/)

    {    

    //let application process the key.

    return EFalse; 

    }

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

// CFepUiLayout::SignalOwner

// Report event to owner

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

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

//            

EXPORT_C void CFepUiLayout::SignalOwner(TInt aEventType, const TDesC& aEventData)

    {

    iLayoutOwner->SignalOwner(aEventType,aEventData);

    }

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

// CFepUiLayout::OnAppEditorTextComing

// Set editor area text when application send text to ui layout

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

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

//         

EXPORT_C TInt CFepUiLayout::OnAppEditorTextComing(const TFepInputContextFieldData& /*aData*/)

    {    

    //do nothing

    return KErrNone;

    }

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

// CFepUiLayout::GetEditorMaxLength

// Get the max editor length of the input context field

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

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

//

EXPORT_C TInt CFepUiLayout::GetInputContextFieldMaxLen()

    {

    return iRootCtrl->GetInputContextFieldMaxLen();

    }

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

// CFepUiLayout::IsValidDestination

// Test whether the rect conflicts with other controls

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

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

//    

EXPORT_C TBool CFepUiLayout::IsValidDestination(const TRect& aRect,

                    CDragBar* aDragBar, TBool& aVInfo,TBool& aHInfo,TBool aFlag)

    {

    //default implementation.

    if(aFlag) //layout is moving

        {

        TRect screen(TPoint(0,0),iScreenSize);        

        screen.Intersection(aRect);

        if(screen != aRect)  //any part of dragbar can't be outside of screen

            {

            aVInfo = EFalse;

            aHInfo = EFalse;            

            return EFalse;

            }

        else

            {            

            aVInfo = ETrue;

            aHInfo = ETrue;            

            return ETrue;

            }

        }

    //check for component moving       

    return iRootCtrl->IsValidDestination(aRect,aDragBar,aVInfo,aHInfo);    

    }

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

// CFepUiLayout::SetRect

// Set layout rect

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

//

EXPORT_C void CFepUiLayout::SetRect(const TRect& aRect)

    {

    TRect layoutRect = Rect();

    layoutRect.Move(Position());

    if(layoutRect != aRect)

        {        

        iRootCtrl->SetRect(aRect);

        LayoutOwner()->LayoutSizeChanged( aRect.Size() );

        LayoutOwner()->SetPosition( aRect.iTl );

        iRootCtrl->GraphicDeviceSizeChanged();

        }

    }

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

// CFepUiLayout::Rect

// Deprecated function

// Get layout rect

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

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

//     

EXPORT_C TRect CFepUiLayout::Rect()

    {

    return iRootCtrl->Rect();

    }

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

// CFepUiLayout::Position

// Get layout start position

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

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

//     

EXPORT_C TPoint CFepUiLayout::Position()

    {

    return LayoutOwner()->LayoutRect().iTl;

    }

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

// CFepUiLayout::SetAppEditorCursor

// Handle changing app editor cursor event

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

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

//     

EXPORT_C void CFepUiLayout::SetAppEditorCursor(const TCursorSelection& aCurSel,

                                                           TBool aReqMoreText)

    {

    TPtrC16 ptr;

    TInt size = sizeof(TBool) + sizeof(TCursorSelection) + 1;

    TUint8* packedData = new TUint8[size];

    if(!packedData)

        return;

    TInt cpLen = sizeof(TCursorSelection);

    Mem::Copy(packedData,&aCurSel,cpLen);

    Mem::Copy(packedData+cpLen,&aReqMoreText,sizeof(TBool));

    ptr.Set(reinterpret_cast<TUint16*>(packedData),size / 2);    

    SignalOwner(ESignalSetAppEditorCursor,ptr);

    delete []packedData;

    }

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

// CFepUiLayout::Destroy

// Destroy the layout

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

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

//     

EXPORT_C void CFepUiLayout::Destroy()

    {

    delete this;

    }    

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

// CFepUiLayout::OnActivate

// Response to layout activation

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

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

//     

EXPORT_C void CFepUiLayout::OnActivate()

    {

    iLayoutReady = ETrue;

    iRootCtrl->OnActivate();

#ifdef RD_TACTILE_FEEDBACK  

    iExtension->iTactileSupported = FeatureManager::FeatureSupported( KFeatureIdTactileFeedback );

#endif // RD_TACTILE_FEEDBACK      

    }

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

// CFepUiLayout::OnDeActivate

// Response to layout de-activation

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

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

//         

EXPORT_C void CFepUiLayout::OnDeActivate()

    {

    iLayoutReady = EFalse;

    iRootCtrl->OnDeActivate();

    }    

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

// CFepUiLayout::SetLayoutPos

// Set layout position

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

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

//     

EXPORT_C void CFepUiLayout::SetLayoutPos(const TPoint& aPt)

    {

    if(aPt != Position())    

        iLayoutOwner->SetPosition(aPt);    

    }

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

// CFepUiLayout::EnableLayoutMoving

// Enable that the layout can be dragged by a dragbar

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

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

//     

EXPORT_C void CFepUiLayout::EnableLayoutMoving(CDragBar* aDragbar)

    {

    if(aDragbar && (iDragbarNum < KMaxDragBarNum))

        {        

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

            {

            if(aDragbar == iDragbarList[i])

                return; //do nothing if already there

            }

        iDragbarList[iDragbarNum] = aDragbar;

        iDragbarNum++;

        //set rootcontrol as an observer of the dragbar

        aDragbar->AddEventObserver(iRootCtrl);

        }