/*

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

	iPopRegion.Close();

	iBubblesArea.Close();

    iBubblesMaskArea.Close();

	iBubblesPos.Close();

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

    MakeVisible( EFalse );

}

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

    {

        return;

    CWindowGc& gc = SystemGc();

        {

        //layout is extended by popup

        }

    }

void CPenUiWndCtrl::RefreshUI()

    {

    StopRefreshTimer();

    if ( iShowPopup )

        {

        iPopupWnd->DrawNow();

        }

    else

        {

        DrawNow();

        }

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

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

    }

void CPenUiWndCtrl::Clean()

    {

    iCursorBmp = NULL;

    iBubblesArea.Reset();

    iBubblesPos.Reset();

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

    }

void CPenUiWndCtrl::DrawCursor(CWindowGc& aGc) const

    {

    aGc.SetPenColor(KRgbBlack);

    aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    aGc.SetBrushColor(KRgbBlack);

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

    }

void CPenUiWndCtrl::UpdateBubble(const CFbsBitmap* aBmp,const CFbsBitmap* aMask,

                                                const TRect& aPos,TBool aFlag)

    {

    TInt idx = iBubblesArea.Find(aBmp);

    if(aFlag)

        {

        if(KErrNotFound == idx)

            {

            iBubblesArea.Append(aBmp);

            iBubblesMaskArea.Append(aMask);

            iBubblesPos.Append(aPos);

            }

        else

            {

            iBubblesPos[idx] = aPos;

            }

        }

    else

        {

        //remove

        if(idx != KErrNotFound)

            {

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

    }

void CPenUiWndCtrl::UpdateChangedArea(const CFbsBitmap* aBmp,const TRect& aPos,TBool aFlag)

    {

    UpdateBubble(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*/)

    {

    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      

    if ( GfxTransEffect::IsRegistered( this ) && !IsVisible())

        {

        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           

    if ( GfxTransEffect::IsRegistered( this ))

        {

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

}

void CPenUiWndCtrl::ShowPopup( const TRect& aRectInScreen, const TRect& aRectInLayout, const TRect& aLayoutTrimRect )

    {

    TPoint offset = aLayoutTrimRect.iTl;

    offset += Position();

    this->SetPosition( offset );

    this->SetSize( aLayoutTrimRect.Size() );

    iPopupWnd->PopUp( aRectInScreen, aRectInLayout );

    iLayoutClipRect = aLayoutTrimRect;

    iShowPopup = ETrue;

    }

void CPenUiWndCtrl::ClosePopup()

    {

    iShowPopup = EFalse;    

    iPopupWnd->Close();

    }

TKeyResponse CPenUiWndCtrl::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ )

    {

    return EKeyWasNotConsumed;

    }

void CPenUiWndCtrl::Invalidate(const TRect& aRect,TBool /*aFullUpdate*/)

    {

    //Window().Invalidate(aRect);

    /*********************************************************************/

    //Invalidate() should be used. But I don't know why there the rect in 

    // Draw is always full-screen in such case. So I change to DrawNow

    // for temprory solution.

    /*********************************************************************/ 

    if(iShowPopup)

        {        

        iPopupWnd->MakeVisible(EFalse);//This is a temproary fix due to pop up UI not updated.

        iPopupWnd->Invalidate(aRect);

        iPopupWnd->MakeVisible(ETrue);//This is a temproary fix due to pop up UI not updated.

        iPopupWnd->Invalidate(aRect);

        }

    else

        {

        iInvalidateRect = aRect;

        Window().Invalidate(aRect);

        }

#ifdef FIX_FOR_NGA

    RestartRefreshTimer();

#endif

    }

void CPenUiWndCtrl::OnActivate(EditorType aType)

    {

    //TBool dim = IsDimmed();

    RestoreSystemFadeStatus();