// Copyright (c) 1995-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:

// Client window functions

// 

//

#include "W32CLICK.H"

#include <graphics/wselement.h>

#include "server.h"

#include "cliwin.h"

#include "gc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "walkwindowtree.h"

#include "ScrDev.H"

#include "wstop.h"

#include "EVQUEUE.H"

#include "KEYCLICK.H"

#include "panics.h"

#include "password.h"

#include "pointer.h"

#include "EVENT.H"

#include "backedupwindow.h"

#include "redrawmsgwindow.h"

#include "ANIM.H"

#include "windowelementset.h"

TBool CWsClientWindow::iAbsoluteFading = EFalse;

const TPoint corner1[1]={TPoint(1,1)};

const TPoint corner2[2]={TPoint(2,1),TPoint(1,1)};

const TPoint corner3[2]={TPoint(3,1),TPoint(1,2)};

const TPoint corner5[4]={TPoint(5,1),TPoint(3,1),TPoint(2,1),TPoint(1,2)};

/*CWsClientWindow*/

CWsClientWindow::CWsClientWindow(CWsClient* aOwner, CScreen* aScreen) : CWsWindow(aOwner,WS_HANDLE_WINDOW,aScreen)

	{

	iWinType=EWinTypeClient;

	}

void CWsClientWindow::ConstructL(const TWsClCmdCreateWindow &aCmd, CWsWindowBase *aParent, TBool aScreenDeviceIsInvalid)

	{

	CWsWindow::Construct();

	NewObjL();

	if (aCmd.clientHandle==NULL)

		OwnerPanic(EWservPanicNullHandle);

#if defined(_DEBUG)

	if (IsClientHandleInUse(aCmd.clientHandle))

		OwnerPanic(EWservPanicDuplicateHandle);

#endif

	iPointerFilter=EPointerFilterEnterExit|EPointerFilterMove|EPointerFilterDrag;

	iClientHandle=aCmd.clientHandle;

	CWsWindow* inherit=static_cast<CWsWindow *>(aParent);

	if (aParent->WinType()==EWinTypeGroup)

		inherit=RootWindow();

	SetPointerCursor(aParent->PointerCursor());

	iAbs=inherit->Abs();

	iOrigin=aParent->Origin();

	iRel.iBr.iX=inherit->Rel().iBr.iX-inherit->Rel().iTl.iX;

	iRel.iBr.iY=inherit->Rel().iBr.iY-inherit->Rel().iTl.iY;

	switch(aCmd.type)

		{

		case EWinRedraw:

			iRedraw=new(ELeave) CWsRedrawMsgWindow(this);

			break;

		case EWinBackedUp:

			iRedraw=new(ELeave) CWsBackedUpWindow(this, aCmd.displayMode);

			iAbs.iBr=iAbs.iTl;

			iRel.iBr=iRel.iTl;

			break;

		case EWinBlank:

			iRedraw=new(ELeave) CWsBlankWindow(this);

			break;

		default:

			OwnerPanic(EWservPanicRedrawType);

		}

	ResetHiddenFlag();

	SetCornerTypeL(EWindowCornerSquare,0,NULL,EFalse);

	CWsWindowBase::ConstructL(aParent);

	if (aScreenDeviceIsInvalid)

		{

		iFlags|=EFlagScreenDeviceInvalid;

		ResetHiddenFlag();

		}

	iRedraw->ConstructL();

	}

void CWsClientWindow::GetBaseAreaOfNode(RWsRegion &aRegion) const

    {

    if (iBaseArea)

        {

        aRegion.Copy(*iBaseArea);

        }

    aRegion.ClipRect(iAbs);

    }

void CWsClientWindow::ClipRegionToBaseArea(RWsRegion &aRegion) const

    {

    if (iBaseArea)

        {

        aRegion.Intersect(*iBaseArea);

        }

    aRegion.ClipRect(iAbs);

    }

void CWsClientWindow::GetClippedBaseArea(RWsRegion &aRegion) const

	{

	const CWsWindowBase* ancestor = BaseParent();	    

	GetBaseAreaOfNode(aRegion);	

	while (ancestor && ancestor->WinType() == EWinTypeClient)

	    {

	    static_cast<const CWsClientWindow*>(ancestor)->ClipRegionToBaseArea(aRegion);       

	    ancestor = ancestor->BaseParent();

	    }

	}

void CWsClientWindow::GetOpaqueBaseAreaOfNode(RWsRegion &aRegion) const

    {

    if (IsTranslucent())

        {

        if (iUserDefinedOpaqueRegion)

            {

            aRegion.Copy(*iUserDefinedOpaqueRegion);

            aRegion.ClipRect(iAbs);

            }

        else

            {

            aRegion.Clear();

            }

        }

    else

        {

        GetBaseAreaOfNode(aRegion);

        }

    }

void CWsClientWindow::ClipRegionToOpaqueBaseArea(RWsRegion& aRegion) const

    {

    if (IsTranslucent())

        {

        if (iUserDefinedOpaqueRegion)

            {

            aRegion.Intersect(*iUserDefinedOpaqueRegion);

            aRegion.ClipRect(iAbs);

            }

        else

            {

            aRegion.Clear();

            }

        }

    else

        {

        ClipRegionToBaseArea(aRegion);

        }

    }

void CWsClientWindow::GetOpaqueClippedBaseArea(RWsRegion &aRegion) const

	{

	const CWsWindowBase* ancestor = BaseParent();

	GetOpaqueBaseAreaOfNode(aRegion);

	while (ancestor && ancestor->WinType() == EWinTypeClient)

	    {

	    static_cast<const CWsClientWindow*>(ancestor)->ClipRegionToOpaqueBaseArea(aRegion);

	    ancestor = ancestor->BaseParent();

	    }

	}

TInt CWsClientWindow::GetNonOpaqueBaseAreaOfNode(RWsRegion &aRegion) const

    {

    aRegion.Clear();

    if (IsTranslucent())

        {

        if(iUserDefinedTransparentRegion)

            {

            aRegion.Copy(*iUserDefinedTransparentRegion);

            aRegion.ClipRect(iAbs);

            return KErrNone;

            }

        }  

    return KErrNotFound;

    }

void CWsClientWindow::ResetHiddenFlag()

//

// Reset the status of the hidden flag based on the current states of the active and invisible flags

//

	{

	CWsClientWindow *parent=static_cast<CWsClientWindow*>(iParent);

	TBool wasHidden = iFlags&EFlagHidden;

	TBool nowHidden = (parent==NULL || 

		              (parent->WinType()==EWinTypeClient && !parent->IsVisible()) ||

	                  !(iFlags&EFlagActive) ||

	                  (iFlags&EFlagInvisible) ||

			          (iFlags&EFlagScreenDeviceInvalid));

	if (nowHidden)

		{

		iFlags|=EFlagHidden;

		iFlags&=~EFlagDrawnToScreen;

		}

	else

		{

		iFlags&=~EFlagHidden;

		}

	if ((!nowHidden) != (!wasHidden))

		{

		// intentionally call the screen directly

		iScreen->ScheduleRegionUpdate(&iVisibleRegion);

		WS_ASSERT_DEBUG(!iDirtyWindowRegion.CheckError(),EWsPanicErrorInRegion);

		WS_ASSERT_DEBUG(!iDirtySpriteRegion.CheckError(),EWsPanicErrorInRegion);

	//	WS_ASSERT_DEBUG(!InvalidArea().CheckError(),EWsPanicErrorInRegion);		//error flag in invalid area may be set in OOM cases

																				//thus the assert statement is caused to fail

		if (wasHidden && iScreen->ChangeTracking() && 

				(!iDirtyWindowRegion.IsEmpty() || !iDirtySpriteRegion.IsEmpty() || !InvalidArea().IsEmpty()))

			{

			// Window has just become visible, schedule it

			iScreen->ScheduleWindow(this);

			}

		}

	}

void CWsClientWindow::ResetHiddenFlags()

	{

	CWsClientWindow *win=this;

	FOREVER

		{

		TUint oldHiddenFlag=win->iFlags&EFlagHidden;

		win->ResetHiddenFlag();

		if ((win->iFlags&EFlagHidden)!=oldHiddenFlag)	// If hidden status hasn't changed nothing to do

			{

			win->SetElementOpacity(IsVisible() ? 0xFF : 0x00);	// Update element visibility

			if (win->Child())

				{

				win=win->Child();

				continue;

				}

			}

		if (win==this)

			return;

		while(!win->NextSibling())

			{

			win=(CWsClientWindow *)win->BaseParent();

			if (win==this)

				return;

			}

		win=win->NextSibling();

		} // for loop ends

	}

void CWsClientWindow::OffsetBaseArea(const TPoint &aOffset)

	{

	iBaseArea->Offset(aOffset);

	//If the given window's position changes, then update.

	if (aOffset.iX || aOffset.iY)

		{

		UpdateElementExtent(&aOffset);

		}

	}

void CWsClientWindow::CalcBaseArea()

//

// The windows basic area before any clipping is done

//

	{

	TInt cornerType=iCornerData&ECornerTypeMask;

	if (cornerType==EWindowCornerRegion)

		iBaseArea->ClipRect(FullRect());

	else

		{

		TSize size=Size();

		iBaseArea->Clear();

		const TPoint *corners=NULL;

		TInt count=0;

		switch(cornerType)

			{

			case EWindowCorner1:

				count=sizeof(corner1)/sizeof(TPoint);

				corners=corner1;

				break;

			case EWindowCorner2:

				count=sizeof(corner2)/sizeof(TPoint);

				corners=corner2;

				break;

			case EWindowCorner3:

				count=sizeof(corner3)/sizeof(TPoint);

				corners=corner3;

				break;

			case EWindowCorner5:

				count=sizeof(corner5)/sizeof(TPoint);

				corners=corner5;

				break;

			default:

				break;

			}

		TInt top=0;

		TInt bot=size.iHeight;

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

			{

			TInt xadjust=corners[index].iX;

			TInt yadjust=corners[index].iY;

			if ((iCornerData&(EWindowCornerNotTL|EWindowCornerNotTR))!=(EWindowCornerNotTL|EWindowCornerNotTR))

				{

				iBaseArea->AddRect(TRect(iCornerData&EWindowCornerNotTL?0:xadjust,top,

										 size.iWidth-(iCornerData&EWindowCornerNotTR?0:xadjust),top+yadjust));

				top+=yadjust;

				}

			if ((iCornerData&(EWindowCornerNotBL|EWindowCornerNotBR))!=(EWindowCornerNotBL|EWindowCornerNotBR))

				{

				iBaseArea->AddRect(TRect(iCornerData&EWindowCornerNotBL?0:xadjust,bot-yadjust,

										 size.iWidth-(iCornerData&EWindowCornerNotBR?0:xadjust),bot));

				bot-=yadjust;

				}

			}

		iBaseArea->AddRect(TRect(0,top,size.iWidth,bot));

		iBaseArea->Offset(Origin());

		iBaseArea->ClipRect(FullRect());

		iBaseArea->Sort();

		}

	}

void CWsClientWindow::GenerateArea(RWsRegion &aArea, TBool aClipTranslucent) const

//

// Create the window area list.

//

	{

	aArea.Clear();

	if (IsVisible())

		{

		aArea.Copy(*iBaseArea);

		aArea.ClipRect(iAbs);

		const CWsClientWindow *win=this;

		FOREVER

			{

			if (win->IsTopClientWindow())

				break;

			ClipWindows(aArea,(CWsClientWindow *)win->BaseParent()->BaseChild(),win,aClipTranslucent);

			win=(CWsClientWindow *)win->iParent;

			}

		TInt tidyCount=0;

		for(const CWsTopClientWindow *cwin=RootWindow()->FirstTopClientWindow();aArea.Count() && cwin!=win;cwin=cwin->NextSiblingMultiParent())

			{

			if (!tidyCount--)

				{

				aArea.Tidy();

				tidyCount=ETidyCountSetting;	// Tidy every ETidyCountSetting times around

				}

			if (cwin->IsVisible())

				{

				if (cwin->IsTranslucent() && !aClipTranslucent)

					{

					if (cwin->iUserDefinedOpaqueRegion)

						{

						aArea.SubRegion(*cwin->iUserDefinedOpaqueRegion);

						}

					}

				else

					{

					aArea.SubRegion(*cwin->iBaseArea);

					}

				}

			}

		aArea.Tidy();

		}

	}

void CWsClientWindow::ClipWindows(TRegion &region,const CWsClientWindow *start, const CWsClientWindow *end, TBool aClipTranslucent)

//

// Remove out of the region the opaque part of the abs rect of all the windows starting from 'start'

// along the sibling list to (and not including) the end window.

//

	{

	for(const CWsClientWindow *win=start;region.Count() && win!=end;win=win->NextSibling())

		{

		if (win->IsVisible())

			{

			if (win->IsTranslucent() && !aClipTranslucent)

				{

				if (win->iUserDefinedOpaqueRegion)

					{

					region.SubRegion(*win->iUserDefinedOpaqueRegion);

					}

				}

			else

				{

				region.SubRegion(*win->iBaseArea);

				}

			}

		}

	}

void CWsClientWindow::GenerateTopRegion(RWsRegion& aRegion) const

	{

	GenerateArea(aRegion,ETrue);

	if (iChild)

		ClipWindows(aRegion,Child(),NULL,ETrue);

	}

void CWsClientWindow::GenerateWindowRegion(RWsRegion &aRegion) const

//

// Calculate the windows clipping region without using the usual stored iArea or iRegion fields

// this function is used by the screen backup code to calculate "what if" regions to work out

// whether something would be visible if the backed up window didn't exist, on this basis we

// don't want to modify the existing copies of iArea & iRegion.

//

	{

	GenerateArea(aRegion,EFalse);

	if (iChild)

		ClipWindows(aRegion,Child(),NULL,EFalse);

	}

const TRegion *CWsClientWindow::DrawingRegion()

	{

	return (&iRedraw->BaseDrawRegion());

	}

void CWsClientWindow::RecalcChildAbs(const TPoint *aOffset)

	{

	CWsClientWindow *win=this;

	FOREVER

		{

		FOREVER

			{

			win->SetAbsFromRel();

			if (aOffset)

				win->OffsetBaseArea(*aOffset);

			if (win->Child()==NULL)

				break;

			win=win->Child();

			}

		FOREVER

			{

			if (win==this)

				return;

			if (win->NextSibling()!=NULL)

				{

				win=win->NextSibling();

				break;

				}

			win=(CWsClientWindow *)win->iParent;	// The cast is safe as the loop is aborted when win==this

			}

		}

	}

void CWsClientWindow::SetAbsFromRel()

	{

	iOrigin=iRel.iTl+iParent->Origin();

	iAbs=iRel;

	iAbs.Move(iParent->Origin());

	iAbs.Intersection(iParent->AbsRect());

	}

void CWsClientWindow::SetExtentL(const TPoint *aPos,const TSize *aSize)

	{

	if (iParent==NULL)

		OwnerPanic(EWservPanicParentDeleted);

	TPoint offset = TPoint(0,0);

	TSize oldSize;

	TSize newSize;

	TBool sizeChanged = EFalse;

	TBool posChanged = EFalse;

	if (aPos)

		{

		offset = *aPos+iParent->Origin()-iOrigin;

		if (offset.iX != 0 || offset.iY != 0)

			{

			posChanged = ETrue;

			}

		}

	if (posChanged)

		{

		TWalkWindowTreeScheduleRedraws wwt;

		WalkWindowTree(wwt, EWalkChildren);

		}

	if (aSize)

		{

		newSize=*aSize;

		if (newSize.iWidth<0)

			newSize.iWidth=0;

		if (newSize.iHeight<0)

			newSize.iHeight=0;

		// This should be the only part of resizing that can fail

		// and it can only fail for backedup windows.

		iRedraw->PrepareForResizeL(newSize,oldSize);

		sizeChanged = *aSize != iRel.Size();

		}

	if (posChanged)

		{

		iRel.Move(offset);

		RecalcChildAbs(&offset);      // Also calls UpdateElementExtent(offset)

		TWalkWindowTreeOffsetTransparentRegions offsetTransparent(offset);

		WalkWindowTree(offsetTransparent, EWalkChildren);

		}

	if (sizeChanged)

		{

		iRel.SetSize(newSize);

		RecalcChildAbs(NULL);

		CalcBaseArea();

		iRedraw->Resize(newSize,oldSize);

		if (Redraw()->HasElement())

		    UpdateElementExtent();

		}

	if ((posChanged || sizeChanged) && Redraw()->HasElement())

		{

		TRect interSection(iParent->Origin(), iParent->Size());