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

// Base classes used for building window server test code

// 

//

#include <e32std.h>

#include <w32std.h>

#include <e32svr.h>

#include <e32property.h>

#include "TLIB.H"

#include <graphics/wsgraphicdrawerinterface.h>

//

// Test code classes

//

// CTWinBase

// CTBaseWin

// CTWin

// CTBackedUpWin

// CTGroupWin

// CTClient

//

//

_LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

class CStopTheScheduler : public CAsyncOneShot

	{

public:

	inline CStopTheScheduler(CTClient* aClient,TInt aPriority,TBool aAll) :CAsyncOneShot(aPriority), iClient(aClient), iAll(aAll) {}

	inline CStopTheScheduler(CTClient* aClient,TInt aPriority) :CAsyncOneShot(aPriority), iClient(aClient) {}

	inline CStopTheScheduler(TInt aPriority) :CAsyncOneShot(aPriority) {}

	void RunL();

public:

	CTClient* iClient;

	TBool iAll;

#ifdef __WINS__

	TInt iCStopTheSchedulerRunCount;

#endif

	};

void TbPanic(TInt aPanic)

	{

	User::Panic(_L("TestBase"),aPanic);

	}

EXPORT_C CTWinBase::CTWinBase(TInt aType) : iType(aType)

	{

	__DECLARE_NAME(_S("CTWinBase"));

	}

EXPORT_C CTWinBase *CTWinBase::Parent() const

	{

	return((CTWinBase *)WinTreeNode()->Parent());

	}

EXPORT_C CTWinBase *CTWinBase::NextSibling() const

	{

	return((CTWinBase *)WinTreeNode()->NextSibling());

	}

EXPORT_C CTWinBase *CTWinBase::PrevSibling() const

	{

	return((CTWinBase *)WinTreeNode()->PrevSibling());

	}

EXPORT_C CTClient *CTWinBase::Client() const

	{

	return(iOwnerWin->Client());

	}

EXPORT_C CTBaseWin *CTWinBase::Child() const

	{

	return((CTBaseWin *)WinTreeNode()->Child());

	}

EXPORT_C TPoint CTWinBase::Position() const

	{

	return(TPoint(0,0));

	}

EXPORT_C void CTWinBase::PointerEnter(const TTime&)

	{

	}

EXPORT_C void CTWinBase::PointerExit(const TTime&)

	{

	}

EXPORT_C void CTWinBase::PointerBufferReady(const TTime&)

	{

	}

EXPORT_C void CTWinBase::PointerL(const TPointerEvent&,const TTime&)

	{

	}

EXPORT_C void CTWinBase::SwitchOn(const TTime &)

	{

	}

EXPORT_C void CTWinBase::ModifiersChanged(const TModifiersChangedEvent &,const TTime &)

	{

	}

EXPORT_C void CTWinBase::AdjustOrdinal(TInt)

	{

	}

EXPORT_C void CTWinBase::AdjustShadow(TInt)

	{

	}

EXPORT_C void CTWinBase::SetVisible(TBool)

	{

	}

EXPORT_C TInt CTWinBase::SubType()

	{

	return(0);

	}

EXPORT_C void CTWinBase::ErrorMessage(const TWsErrorMessage&, const TTime &)

	{

	}

EXPORT_C void CTWinBase::__DbgTestInvariant() const

	{

	WinTreeNode()->__DbgTestInvariant();

	}

// CTBaseWin //

EXPORT_C CTBaseWin::CTBaseWin(TInt aType) : CTWinBase(aType)

	{

	__DECLARE_NAME(_S("CTBaseWin"));

	}

EXPORT_C CTBaseWin::~CTBaseWin()

	{

	}

EXPORT_C void CTBaseWin::RelinquishFocus()

	{

	CTWinBase *parent=Parent();

	CTWindowGroup *group=Group();

	CTWinBase *child=group->Child();

	if (child==this)

		child=child->NextSibling();

	group->SetCurrentWindow((parent->iType==EWinTypeClient) ? (CTBaseWin *)parent : (CTBaseWin *)child);

	}

EXPORT_C void CTBaseWin::SetVisible(TBool aState)

	{

	BaseWin()->SetVisible(aState);

	}

EXPORT_C const RWindowTreeNode *CTBaseWin::WinTreeNode() const

	{

	return((const RWindowTreeNode *)BaseWin());

	}

EXPORT_C RWindowTreeNode *CTBaseWin::WinTreeNode()

	{

	return((RWindowTreeNode *)BaseWin());

	}

EXPORT_C void CTBaseWin::InitWin()

	{

	}

EXPORT_C void CTBaseWin::ConstructExtLD(CTWinBase &aParent, const TPoint &aPos, const TSize &aSize)

//

// Call ConstructL, SetExt and either of these fail destroy this and leave

//

	{

	TRAPD(err,ConstructL(aParent));

	if (err!=KErrNone)

		goto celd_err;

	TRAP(err,SetExtL(aPos,aSize));

	if (err!=KErrNone)

		{

celd_err:

		delete this;

		User::Leave(err);

		}

	}

EXPORT_C void CTBaseWin::ConstructL(CTWinBase &aParent)

	{

	TInt ret;

	__ASSERT_DEBUG(aParent.iOwnerWin!=NULL,TbPanic(ETestBasePanicNullOwnerWin));

	iOwnerWin=aParent.iOwnerWin;

	if ((ret=ConstructWin(aParent))==KErrNone)

		{

		//TFontSpec fspec(KTestFontTypefaceName,200);

		//User::LeaveIfError(Client()->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)iFont, fspec));

		TFontSpec fspec(KTestFontTypefaceName,17);

		User::LeaveIfError(Client()->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)iFont, fspec));

		AdjustShadow(1);

		InitWin();

		iSize=BaseWin()->Size();

		}

	User::LeaveIfError(ret);

	}

EXPORT_C void CTBaseWin::Activate()

	{

	BaseWin()->Activate();

	}

EXPORT_C void CTBaseWin::SetFullScreenExtL()

	{

	SetExtL(TPoint(0,0), Parent()->Size());

	}

EXPORT_C void CTBaseWin::SetDefaultExtL()

	{

	TSize size=Parent()->Size();

	size.iWidth>>=1;

	size.iHeight>>=1;

	SetExtL(TPoint(size.iWidth>>1,size.iHeight>>1), size);

	}

EXPORT_C void CTBaseWin::AssignGC(CWindowGc &aGc)

	{

	iGc= &aGc;

	}

EXPORT_C void CTBaseWin::SetPos(const TPoint &aPos)

	{

	BaseWin()->SetPosition(aPos);

	iPos=aPos;

	}

EXPORT_C void CTBaseWin::SetInitialPos(const TPoint &aPos)

	{

	TSize screen=Client()->iScreen->SizeInPixels();

	TPoint pos(aPos);

	TPoint botLeft=pos+iSize;

	if (botLeft.iX>screen.iWidth)

		pos.iX=Max(0,pos.iX-botLeft.iX+screen.iWidth);

	if (botLeft.iY>screen.iHeight)

		pos.iY=Max(0,pos.iY-botLeft.iY+screen.iHeight);

	SetPos(pos);

	}

EXPORT_C void CTBaseWin::SetExtL(const TPoint &aPos, const TSize &aSize)

	{

	User::LeaveIfError(BaseWin()->SetExtentErr(aPos,aSize));

	iPos=aPos;

	iSize=aSize;

	Resized(iSize);

	}

EXPORT_C void CTBaseWin::AdjustSizeL(TInt xMove,TInt yMove,TInt modifiers)

	{

	if (modifiers&EModifierCtrl)	// 4 times the movement

		{

		xMove<<=2;

		yMove<<=2;

		}

	if (modifiers&EModifierShift)

		{

		TSize size(iSize.iWidth+xMove,iSize.iHeight+yMove);

		if (size.iWidth<0)

			size.iWidth=0;

		if (size.iHeight<0)

			size.iHeight=0;

		if (modifiers&EModifierCtrl)

			{

			TPoint pos(iPos);

			pos.iX-=(xMove>>1);

			pos.iY-=(yMove>>1);

			SetExtL(pos,size);

			}

		else

			SetSizeL(size);

		}

	else

		SetPos(TPoint(iPos+TPoint(xMove,yMove)));

	}

EXPORT_C void CTBaseWin::SetSizeL(const TSize &aSize)

	{

	User::LeaveIfError(BaseWin()->SetSizeErr(aSize));

	iSize=aSize;

	Resized(iSize);

	}

EXPORT_C TSize CTBaseWin::Size() const

	{

	return(iSize);

	}

EXPORT_C void CTBaseWin::Resized(const TSize &aSize)

//

	{

	SetDragRect(TRect(aSize));

	}

EXPORT_C TPoint CTBaseWin::Position() const

	{

	return(BaseWin()->Position());

	}

EXPORT_C void CTBaseWin::Delete(CTBaseWin *aWin)

	{

	RHeap& heap = User::Heap();

	TUint8* base=heap.Base();

	TInt size=heap.Size();

	TUint8* cell=REINTERPRET_CAST(TUint8*,aWin);

	__ASSERT_ALWAYS(base<=cell && cell<base+size, TbPanic(ETestBasePanicInvalidHeapAddress));

	CTWinBase *tmp=aWin;

	CTWinBase *win2;

	CTBaseWin *curwin=NULL;

	if (tmp->Group())

		curwin=tmp->Group()->CurWin();

	do

		{

		win2=tmp;

		while((tmp=win2->Child())!=NULL)

			win2=tmp;

		if ((tmp=win2->NextSibling())==NULL)

			tmp=win2->Parent();

		if (curwin==win2)

			((CTBaseWin *)win2)->RelinquishFocus();

		delete win2;

		} while(win2!=aWin);

	}

EXPORT_C void CTBaseWin::KeyUpL(const TKeyEvent &,const TTime&)

	{

	}

EXPORT_C void CTBaseWin::KeyDownL(const TKeyEvent &,const TTime&)

	{

	}

EXPORT_C void CTBaseWin::WinKeyL(const TKeyEvent &,const TTime&)

	{

	}

EXPORT_C void CTBaseWin::PointerL(const TPointerEvent &aPointer,const TTime&)

	{

	if (iDragging)

		{

		if (aPointer.iType==TPointerEvent::EDrag)

			SetPos(aPointer.iParentPosition-iDragPos);

		else

			iDragging=EFalse;

		return;

		}

	if (aPointer.iType==TPointerEvent::EButton1Down)

		{

		if (aPointer.iModifiers&EModifierCtrl)

			{

			if (aPointer.iModifiers&EModifierShift)

				BaseWin()->SetOrdinalPosition(-1);

			else

				BaseWin()->SetOrdinalPosition(0);

			return;

			}

#if defined(__WINS__)

		else if (aPointer.iModifiers&EModifierShift)

			__DbgTestInvariant();

#endif

		else

			{

			Group()->SetCurrentWindow(this);

			if (iDragRect.Contains(aPointer.iPosition))

				{

				iDragging=ETrue;

				iDragPos=aPointer.iPosition;

				return;

				}

			}

		}

	}

EXPORT_C void CTBaseWin::DragDropL(const TPointerEvent &,const TTime &)

	{

	}

EXPORT_C void CTBaseWin::AdjustOrdinal(TInt aAdjust)

	{

	TInt pos=BaseWin()->OrdinalPosition()+aAdjust;

	if (pos>=0)

		BaseWin()->SetOrdinalPosition(pos);

	}

EXPORT_C void CTBaseWin::AdjustShadow(TInt aAdjust)

	{

	iShadow+=aAdjust;

	if (iShadow<0)

		iShadow=0;

	BaseWin()->SetShadowHeight(iShadow);

	}

EXPORT_C void CTBaseWin::DrawBorder()

	{

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->DrawRect(TRect(iSize));

	iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	}

EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc, TDisplayMode *aMode,TBool aVisible,TInt aTransparency)

	{

	ConstructL(*parent);

	if (aMode)

		BaseWin()->SetRequiredDisplayMode(*aMode);

	SetExtL(pos,size);

	if (!aVisible)

		BaseWin()->SetVisible(aVisible);

	if (aTransparency!=ENoTransparency)

		{

		TInt err=((RWindow*)(BaseWin()))->SetTransparencyFactor(TRgb::_Gray256(aTransparency));	

		User::LeaveIfError(err);	//asked for transparency when not got none!

		}

	Activate();

	AssignGC(aGc);

	}

EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc, TDisplayMode *aMode)

	{

	SetUpL(pos,size,parent,aGc,aMode,ETrue);

	}

EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc,TBool aVisible)

	{

	SetUpL(pos,size,parent,aGc,NULL,aVisible);

	}

EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)

	{

	SetUpL(pos,size,parent,aGc,NULL,ETrue);

	}

EXPORT_C void CTBaseWin::SetDragRect(const TRect &aRect)

	{

	BaseWin()->PointerFilter(EPointerFilterDrag,0);	// Clear the drag filter

	BaseWin()->SetPointerGrab(ETrue);

	iDragRect=aRect;

	}

EXPORT_C CTWindowGroup *CTBaseWin::Group() const

	{

	return(iOwnerWin);

	}

EXPORT_C void CTBaseWin::FocusChanged(TBool )

	{

	}

EXPORT_C CTBaseWin *CTBaseWin::Next()

	{

	CTWinBase *win;

	CTWinBase *ret=Child();

	if (ret==NULL)

		{

		win=this;

		while((ret=win->NextSibling())==NULL)

			{

			ret=win;

			win=win->Parent();

			if (win==NULL)	// Group window

				{

				ret=ret->Child();

				break;

				}

			}

		}

	return((CTBaseWin *)ret);

	}

EXPORT_C CTBaseWin *CTBaseWin::Prev()

	{

	CTWinBase *par=Parent();

	CTWinBase *win;

	CTWinBase *child;

	if ((win=PrevSibling())==NULL)

		{

		if (par->iType==EWinTypeGroup)

			{

			CTWinBase *win2=par->Child();

			do

				{

				win=win2;

				while((win2=win->NextSibling())!=NULL)

					win=win2;

				win2=win->Child();

				} while(win2!=NULL);

			}

		else

			win=par;

		}

	else

		{

		child=win->Child();

		while(child!=NULL)

			{

			win=child;

			child=child->NextSibling();

			}

		}

	return((CTBaseWin *)win);

	}

//EXPORT_C void CTBaseWin::SetDefaultExt()

//	{

//	TbPanic(ETestBasePanicUnimplementedBaseFunction);

//	}

EXPORT_C void CTBaseWin::Draw()

	{