/*

* 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:

*

*/

#include <AknSgcc.h>

#include <AknIncallBubbleNotify.h>

#include <avkon.hrh>

#include <eikappui.h>

#include <apgwgnam.h>

#include "penuiwndctrl.h"

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include <e32property.h>

#include <avkondomainpskeys.h>

#endif

#include "peninputcmd.h"

const TInt KAknCapServerUid = 0x10207218;

const TInt KAknNotifySrvUid = 0x10281EF2;  

const TInt KAutoRefreshTimer = 10; //ms

const TInt KAutoRefreshLongTimer = 1000; //ms

TInt AutoRefreshTimerCallback( TAny* aObject )

    {

    CPenUiWndCtrl* wnd = static_cast<CPenUiWndCtrl*>( aObject );

    wnd->RefreshUI();

    return 0;

    }

CPenUiWndCtrl::CPenUiWndCtrl(RWindowGroup& aWndGroup,CFbsBitmap * aBitmap)

    :iWndGroup(aWndGroup),

     iBitmap(aBitmap),

     iAknUiSrv(CAknSgcClient::AknSrv())

{

}

CPenUiWndCtrl::~CPenUiWndCtrl()

{

    delete iPopupWnd;

	delete iIncallBubble;  

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    if ( GfxTransEffect::IsRegistered( this ) )

        {

        // abort component effects (possibly appear effect) 

        // if aknnote gets destroyed without user interaction or timers

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort );

        GfxTransEffect::Deregister(this); //Always deregister in destructor.

        }    

#endif   

    if ( iAutoRefreshTimer && iAutoRefreshTimer->IsActive() )

        {

        iAutoRefreshTimer->Cancel();

        }

    delete iAutoRefreshTimer; 

	Clean();

	delete iCursorWnd;   

}

void CPenUiWndCtrl::ConstructL()

{

    CreateWindowL(iWndGroup);

    SetComponentsToInheritVisibility();

    Window().SetRequiredDisplayMode( EColor16MA );

    iIncallBubble = CAknIncallBubble::NewL();        

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS    

    // only change registration, if not registered, don't register

    if (!GfxTransEffect::IsRegistered( this ) ) 

        {

        GfxTransEffect::Register( this, TUid::Uid( 0x2000B477 ));

        }

#endif    

  //  ActivateL();

    iPopupWnd = CPenUiPopWnd::NewL(iWndGroup,iBitmap,this);

    iAutoRefreshTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iCursorWnd = new (ELeave) CCursorWindow(this);

    //iCursorWnd->ConstructL(this);

    iCursorWnd->SetContainerWindowL(*this);

    // Update the cursor color

    SetCursorColor();

    MakeVisible( EFalse );

}

void CPenUiWndCtrl::Draw(const TRect& aRect) const

    {

    if (iNotUpdating)

        return;

    CWindowGc& gc = SystemGc();

    if (iShowPopup)

        {

        //layout is extended by popup

        TRect rect = aRect;

        rect.Intersection(iLayoutClipRect);

        TPoint pos = rect.iTl - iLayoutClipRect.iTl;

        gc.BitBlt(pos, iBitmap, rect);

#ifdef FIX_FOR_NGA

        //draw bubble

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

            {

            gc.BitBlt(iBubblesPos[i].iTl, iBubblesArea[i]);

            }

#endif   

        return;

        //layout is extended by popup

        //gc.SetClippingRect( iLayoutClipRect );

        }

#ifdef FIX_FOR_NGA

    gc.BitBlt(TPoint(0, 0), iBitmap, Rect());

    //draw bubble

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

        {

        gc.BitBlt(iBubblesPos[i].iTl, iBubblesArea[i]);

        }

#else    

    gc.BitBlt(aRect.iTl,iBitmap,aRect);

#endif     

    }

void CPenUiWndCtrl::RefreshUI()

    {

    StopRefreshTimer();

    if ( iShowPopup )

        {

        iPopupWnd->DrawNow();

        }

    else

        {

        DrawNow();

        }

    CCoeEnv::Static()->WsSession().Flush();

    CCoeEnv::Static()->WsSession().Finish();

    }

void CPenUiWndCtrl::Clean()

    {

    iCursorBmp = NULL;

    iBubblesArea.Close();

    iBubblesCtrl.Close();

    iBubblesPos.Close();

	iBubblesMaskArea.Close();

	iPopRegion.Close();

    iChangedBmp= NULL;

    iBackground = EFalse;

    iNotUpdating = EFalse;

    }

CCursorWindow::CCursorWindow(CPenUiWndCtrl* aParent)

                            :iParent(aParent) 

    {

    }

void CCursorWindow::SetCursorVisible(TBool aFlag)

    {

    iCursorVisible = aFlag;

    DrawNow();

    }

void CCursorWindow::Draw(const TRect &aRect ) const

    {

    if(!iCursorVisible)

        return;

    CWindowGc& gc = SystemGc();

    iParent->DrawCursor(gc);  

    }

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

// CPenUiWndCtrl::SetCursorColor

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

//

void CPenUiWndCtrl::SetCursorColor()

	{

	// Set default cursor color to black

	TRgb color( KRgbBlack );

	// if the skin is enabled

    if ( AknsUtils::AvkonSkinEnabled())

        {

        // Get the text color under current theme

        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

	                               color, 

	                               KAknsIIDQsnTextColors, 

	                               EAknsCIQsnTextColorsCG60 );

        }

    // Set the cursor color

    iCursorColor = color;

	}

void CPenUiWndCtrl::DrawCursor(CWindowGc& aGc) const

    {

    aGc.SetPenColor( iCursorColor );

    aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    aGc.SetBrushColor( iCursorColor );

    aGc.SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

    aGc.SetPenStyle(CGraphicsContext::ESolidPen);

    aGc.SetPenSize( TSize(1,1));

    TRect drawRect = iCursorRect;

    if(!iPopRegion.IsEmpty() && iPopRegion.Intersects(iCursorRect))

        {

        RRegion r;

        r.AddRect(iCursorRect);

        const TRect* rl = iPopRegion.RectangleList();

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

            {

            drawRect = iCursorRect;

            drawRect.Intersection(rl[i]);

            if(!drawRect.IsEmpty())

                r.SubRect(drawRect);

            }

        for(TInt ii = 0; ii < r.Count(); ++ii)

            {

        aGc.DrawRect(r.RectangleList()[ii]);

            }

        r.Close();

        }

    else

        aGc.DrawRect(iCursorRect);

    // restore normal draw mode

    aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);

    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

    }

void CPenUiWndCtrl::UpdateCursor(TBool aOnFlag,const CFbsBitmap* aCursorBmp,const TRect& aRect)

    {

    if(iNotUpdating || !IsReadyToDraw())

        {

        //some times when layout is diabled, the cursor is still change its pos, and draw to the last place

        //when layout enabled. So we set the cursor invisible, and wait for next cursor updating event.

		iCursorWnd->SetCursorVisible(EFalse);

        return;

        }

    iCursorPos = aRect.iTl;

    if(iCursorRect != aRect)

        {

        iCursorRect = aRect;

        iCursorWnd->SetRect(iCursorRect);

        }

    iCursorWnd->SetCursorVisible(aOnFlag);

    }

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

// CPenUiWndCtrl::UpdateBubble

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

//

void CPenUiWndCtrl::UpdateBubble( const TUint32 aCtrl, 

		                          const CFbsBitmap* aBmp,

		                          const CFbsBitmap* aMask,

                                  const TRect& aPos,

                                  TBool aFlag )

    {

	// Check whether the Ctrl address is exist

	TInt idx = iBubblesCtrl.Find( aCtrl );

    if(aFlag)

        {

        if(KErrNotFound == idx)

            {

            iBubblesCtrl.Append( aCtrl );

            iBubblesArea.Append(aBmp);

            iBubblesMaskArea.Append(aMask);

            iBubblesPos.Append(aPos);

            }

        else

            {

            iBubblesPos[idx] = aPos;

            }

        }

    else

        {

        //remove

        if(idx != KErrNotFound)

            {

            iBubblesCtrl.Remove( idx );

            iBubblesArea.Remove(idx);

            iBubblesMaskArea.Remove(idx);

            iBubblesPos.Remove(idx);            

            }        

        }

    Invalidate(Rect(), ETrue);

    }

void CPenUiWndCtrl::UpdateICFArea(const CFbsBitmap* aBmp,const TPoint& aPos)

    {

    iICFBmp = const_cast<CFbsBitmap*>(aBmp);

    iIcfPos = aPos;

    Invalidate(Rect(), ETrue);   

    }

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

// CPenUiWndCtrl::UpdateChangedArea

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

//

void CPenUiWndCtrl::UpdateChangedArea( const TUint32 aCtrl, 

		const CFbsBitmap* aBmp,const TRect& aPos,TBool aFlag)

    {

    UpdateBubble( aCtrl, aBmp, 0, aPos, aFlag );

    return;    

    }

void CPenUiWndCtrl::SetPopupArea(const TRect& aRect, TBool aFlag)

    {

    if(aFlag) //add pop area

        {

        iPopRegion.AddRect(aRect);

        }

    else

        {

        iPopRegion.SubRect(aRect);

        }

    }

TInt CPenUiWndCtrl::WndPriority()

    {

    return iPriority;

    }

TUid CPenUiWndCtrl::WindowGroupNameAppUidL( RWsSession& aWS, TInt aWGId )

    {

    CApaWindowGroupName* wg = CApaWindowGroupName::NewLC( aWS,aWGId );

    TUid id = wg->AppUid();

    CleanupStack::PopAndDestroy(wg);

    return id;

    }

TInt CPenUiWndCtrl::GetWndPriority()

    {

    RWsSession &ws = CCoeEnv::Static()->WsSession();

    TInt wgId =ws.GetFocusWindowGroup();    

    TUid id = {0x00000000};

    TRAP_IGNORE( id = WindowGroupNameAppUidL( ws, wgId ) );

    TBool isGlobalServs = ( id.iUid == KAknCapServerUid || id.iUid == KAknNotifySrvUid );

    if( ( iInGlobalEditorState && isGlobalServs ) || !isGlobalServs )

        {

         //TUid id = GetFocusAppUid();

        //set the window group priority so as pen UI can be shown and global notes can also

        //be shown.

        TInt priority = ws.GetWindowGroupOrdinalPriority(wgId);

        (priority == ECoeWinPriorityNormal) ? ++priority : priority;// + 1;

        iPreEditorPriority = priority;

        return priority;

        }

    return iPreEditorPriority;

    }

void CPenUiWndCtrl::ShowPenUiL(TBool /*aDimmed*/)

    {

    iCursorWnd->SetCursorVisible(EFalse);

    if (iResourceChange)

        {

        ActivateL();

        iIncallBubble->SetIncallBubbleFlagsL( EAknStatusBubbleInputShow );

        MakeVisible( ETrue );

    	ClaimPointerGrab( ETrue );

        return;

        }

    TInt priority = GetWndPriority();

    iPriority =  priority;

    iWndGroup.SetOrdinalPosition( 0, iPriority);

    DrawableWindow()->SetOrdinalPosition( 0, iPriority);

    //OnActivate();

    iWndGroup.SetNonFading(ETrue);

    //ChangeSysteFadeStatus();

    ActivateL();

    iIncallBubble->SetIncallBubbleFlagsL( EAknStatusBubbleInputShow );

   // MakeVisible( ETrue );

	ClaimPointerGrab( ETrue );

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS      

        {

        this->MakeVisible(EFalse);

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort ); 

        //If still visible, do a transition to invisible state.

        CAknTransitionUtils::SetAllParents(this);

        GfxTransEffect::Begin(this, KGfxControlAppearAction);

        GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);

        TRect demarcation;

        CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, 

                                            demarcation);

        GfxTransEffect::SetDemarcation(this, demarcation);

        //todo fix NGA effects error

        CCoeEnv::Static()->WsSession().Finish();

        User::After( 1 );

        this->MakeVisible(ETrue);

        GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);

        GfxTransEffect::End(this);

         }

    else

        {

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS   

        MakeVisible( ETrue );

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS            

        }

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS       

    }

void CPenUiWndCtrl::ClosePenUi(TBool aResChanging)

    {

    if (aResChanging)

        {

        TRAP_IGNORE(iIncallBubble->SetIncallBubbleFlagsL( EAknStatusBubbleInputHide ));

        MakeVisible( EFalse );

        return;

        }

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS           

        {

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort ); 

        //If still visible, do a transition to invisible state.

        CAknTransitionUtils::SetAllParents(this);

        GfxTransEffect::Begin(this, KGfxControlDisappearAction);

        GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);

        TRect demarcation;

        CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, 

                                            demarcation);

        GfxTransEffect::SetDemarcation(this, demarcation);

        //todo fix NGA effects error

        CCoeEnv::Static()->WsSession().Finish();

        User::After( 1 );

        this->MakeVisible(EFalse);

        GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);

        GfxTransEffect::End(this);

         }

    else

        {

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS   

        MakeVisible( EFalse );

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS            

        }

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS

    iShowPopup = EFalse;

    iWndGroup.SetOrdinalPosition( -1, ECoeWinPriorityNormal-1 );

    DrawableWindow()->SetOrdinalPosition(-1, ECoeWinPriorityNormal-1 );

    TRAP_IGNORE(iIncallBubble->SetIncallBubbleFlagsL( EAknStatusBubbleInputHide ));

}