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

// Very simple test program to connect to the window server

// 

//

#include <e32std.h>

#include "W32STD.H"

#include <e32svr.h>

#include "../SERVER/w32cmd.h"

#include "../tlib/testbase.h"

#include "ANIMWIN.H"

#include "HNDLODR.H"

#define TEST_BITMAP_NAME _L("Z:\\WSTEST\\TEST.MBM")

_LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

//

// TestWindow class

//

class TestClient;	// Forward reference

class TestWindow1 : public CTWin

	{

public:

	TestWindow1();

	void Resized(const TSize &aNewSize);

	void Draw();

	void WinKeyL(const TKeyEvent &aKey,const TTime &);

private:

	TBool iDrawPolygon;

	};

class TestWindow2 : public CTWin

	{

	enum EPointerState

		{

		EPointerIn,

		EPointerOut,

		EPointerUndefined,

		};

public:

	TestWindow2();

	~TestWindow2();

	void InitWinL();

	void Draw();

	void PointerL(const TPointerEvent &aPointer,const TTime &aTime);

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	void NewText(TPoint &pos,TInt &width,TDes &des);

	void PointerState(EPointerState aState);

	void PointerEnter(const TTime &aTime);

	void PointerExit(const TTime &aTime);

	void SetBufBits();

	void RequestPointerRepeat();

private:

	void SwitchOn(const TTime &aTime);

private:

	TBuf<0x40> iBuf;

	TBuf<0x40> iBufBits;

	TBuf<0x40> iBufMem;

	TPoint iPos;

	TPoint iPosBits;

	TPoint iPosMem;

	TInt iWid;

	TInt iWidBits;

	TInt iWidMem;

	TInt iFontHeight;

	EPointerState iPointerState;

	TUint32 iFilter;

	TBool iCapture;

	TBool iGrab;

	TRgb iBackColor;

	TInt iRepeatCount;

	TRect iRepeatRect;

	};

class TestWindow3 : public CTWin

	{

public:

	TestWindow3();

	~TestWindow3();

	void Draw();

	void InitWinL();

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	void Resized(const TSize &aNewSize);

	void SetShape(TInt aShapeNum);

	void ScreenDeviceChangedL();

private:

	CWsBitmap *iBitmap;

	TInt iShapeNum;

	TInt iCornerFlags;

	TCornerType iCornerType;

	};

class TestWindow4 : public CTWin

	{

public:

	TestWindow4();

	void InitWin();

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	void Resized(const TSize &aSize);

	void Draw();

	void Draw(TBool aSetCursor);

private:

	void SetSwappedSize();

	void SetCursor(const TPoint &aPos);

private:

	TBuf<300> TxtBuf;

	TPoint iBasePos;

	TBool iVertical;

	TSize iSwappedSize;

	//TInt iTemp;

	};

class TestWindow5 : public CTBackedUpWin

	{

public:

	TestWindow5(TBool aGrey2);

	void Draw();

	void InitWinL();

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	void Resized(const TSize &aNewSize);

private:

	CFbsBitmap iBrushBit;

	TInt iOrdPri;

	};

class TestWindow6 : public CTBackedUpWin

	{

public:

	enum {KPointerMoveBufferSize=32};

public:

	TestWindow6(TBool aGrey2);

	~TestWindow6();

	void Draw();

	void InitWinL();

	void PointerL(const TPointerEvent &aPointer,const TTime &aTime);

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	virtual void AssignGC(CWindowGc &aGc);

	void Resized(const TSize &aNewSize);

	void PointerBufferReady(const TTime &aTime);

private:

	TSize iOldSize;	// Needed as part of resizing after old size has been lost

	TBool iDragging;

	TInt iGray;

	CWindowGc *iGc2;

	CWindowGc *iCurGc;

	};

class TestWindow7 : public CTBackedUpWin

	{

private:

	enum {EPointerModes=3};

public:

	TestWindow7(TBool aGrey2);

	~TestWindow7();

	void InitWinL();

	void Draw();

	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);

	void Resized(const TSize &aNewSize);

/*private:

	void createBitmapL(CFbsBitmap *aBitmap, CFbsBitmapDevice *&aBitmapDevice, const TSize &aSize, TBool aDoMask);

	void createBitmap2L(CFbsBitmap *aBitmap, CFbsBitmapDevice *&aBitmapDevice, const TSize &aSize, TBool aDoMask);

	void InitPointerCursorL(RWsPointerCursor &aSprite, const TSize &aSize, TInt aFlags);

	void InitSpriteL(RWsSprite &aSprite, const TPoint &aPos, const TSize &aSize, TTimeIntervalMicroSeconds32 aOnTime, TTimeIntervalMicroSeconds32 aOffTime, TInt aFlags);*/

private:

	CTSprite *iSprite1;

	CTSprite *iSprite2;

	CTSprite *iSprite3;

	CTSprite *iSprite4;

	CTSprite *iSprite5;

	CTPointerCursor *iPointerCursor;

	CFbsBitmap *iSpriteBitmap;

	CFbsBitmap *iSpriteMaskBitmap;

	TInt iPointerMode;

	TPoint iPos1;

	TPoint iPos2;

	TPoint iPos3;

	TPoint iPos4;

	TPoint iPos5;

	TPoint *iCurPos;

	CTSprite *iCurSprite;

	};

class TestWindow8 : public CTBlankWindow

	{

public:

	TestWindow8();

	void Draw();

	void InitWin();

	};

class TestWindow9 : public CTWin

	{

public:

	TestWindow9();

	void Draw();

	void WinKeyL(const TKeyEvent &aKey,const TTime &);

	void InitWinL();

	void Play();

private:

	CFbsBitmap iBitmap;

	TSize iVideoSize;

	};

class TestWindow10 : public CTWin

	{

public:

	TestWindow10();

	void Draw();

	void InitWin();

	void WinKeyL(const TKeyEvent &aKey,const TTime &);

	};

class TestWindow12 : public CTWin

	{

public:

	TestWindow12();

	void Draw();

	void InitWin();

	void WinKeyL(const TKeyEvent &aKey,const TTime &);

	};

class TestWindowGroup : public CTWindowGroup

	{

public:

	TestWindowGroup(CTClient *aClient);

	virtual void ConstructL();

	virtual void KeyL(const TKeyEvent &aKey,const TTime &aTime);

	void ScreenDeviceChanged();

	void RunLaunchAndShootTestL();

	void MillionsOfSessions();

	inline void SetHandWriting(CHandWriting* aHand) {iHand=aHand;}

private:

	CHandWriting* iHand;

	TBool iIncludeChildren;

	};

class TestClient : public CTClient

	{

public:

	TestClient();

	~TestClient();

	void ConstructL();

	TInt EventLoop();

	void Exit();

	void SetCurrentWindow(CTWinBase *aWindow);

	CTBaseWin *CreateTestWindowL(TInt type,TPoint pos,TSize size,CTWinBase *parent,CWindowGc &gc,TBool aAlternate=EFalse);

	void AdjustLightSource(TInt aX,TInt aY);

private:

	inline TestWindowGroup* TestWindow() {return STATIC_CAST(TestWindowGroup*,iGroup);}

private:

	CHandWriting *iHandWriting;

	TPoint ShadowOffset;

	};

//const TInt Xmove=8;

//const TInt Ymove=6;

const TInt Xmove=1;

const TInt Ymove=1;

LOCAL_D const TUint KTestThreadHeapSize=0x10000;

enum TConnectPanic

	{

	EConnectPanicRedrawToBackedUpWindow,

	EConnectPanicRequiredDisplayMode,

	EConnectPanicDragEvent,

	};

TInt RunLaunchAndShootTest(TAny *);

void Panic(TInt aPanic)

	{

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

	}

//

// Individual window sub-classes

//

TestWindow1::TestWindow1() : CTWin()

	{

	__DECLARE_NAME(_S("TestWindow1"));

	}

void TestWindow1::Draw()

//This function is virtual and so cannot have an 'L' at the end of it's name

	{

	TInt i;

	iGc->SetBrushColor(TRgb::Gray16(14));

	iGc->Clear();

	iGc->SetPenColor(TRgb::Gray16(8));

	iGc->SetBrushColor(TRgb::Gray16(0));

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	CArrayFixFlat<TPoint> *pnts;

	pnts=new(ELeave) CArrayFixFlat<TPoint>(20);

	TPoint mid(iSize.iWidth>>1,iSize.iHeight>>1);

	for(i=0;i<mid.iX;i+=4)

		{

		pnts->AppendL(TPoint(mid.iX-i,mid.iY-i));

		pnts->AppendL(TPoint(mid.iX+i+1,mid.iY-i-1));

		pnts->AppendL(TPoint(mid.iX+i+2,mid.iY+i+2));

		pnts->AppendL(TPoint(mid.iX-i-3,mid.iY+i+3));

		}

	if (iDrawPolygon)

		iGc->DrawPolygon(pnts,CGraphicsContext::EAlternate);

	else

		iGc->DrawPolyLine(pnts);

	delete pnts;

//

	TPoint polygon[8];

	polygon[0]=TPoint(mid.iX-8,mid.iY-16);

	polygon[1]=TPoint(mid.iX+8,mid.iY-16);

	polygon[2]=TPoint(mid.iX+16,mid.iY-8);

	polygon[3]=TPoint(mid.iX+16,mid.iY+8);

	polygon[4]=TPoint(mid.iX+8,mid.iY+16);

	polygon[5]=TPoint(mid.iX-8,mid.iY+16);

	polygon[6]=TPoint(mid.iX-16,mid.iY+8);

	polygon[7]=TPoint(mid.iX-16,mid.iY-8);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGc->DrawPolygon(&polygon[0],sizeof(polygon)/sizeof(polygon[0]));

	}

void TestWindow1::Resized(const TSize &aNewSize)

	{

	iWin.Invalidate();

	CTBaseWin::Resized(aNewSize);

	}

/*void AFunction(TDesC& des)

	{

	TDesC *abc=&des;

	TInt a=3+4;

	}

void AFunction2(TDes& des)

	{

	TDes *abc=&des;

	TInt a=3+4;

	}*/

void TestWindow1::WinKeyL(const TKeyEvent &aKey,const TTime &)

	{

	if (aKey.iCode=='p')

		{

		RWindow win1(Client()->iWs);

		win1.Construct(iWin,1);

		RWindow win2(Client()->iWs);

		win2.Construct(win1,1);

		win1.Close();

		win2.SetExtent(TPoint(1,2),TSize(3,4));

		Client()->iWs.Flush();

		}

	else if (aKey.iCode=='q' || aKey.iCode=='Q')

		{

		RWindowGroup group1(Client()->iWs);

		RWindowGroup group2(Client()->iWs);

		group1.Construct(1);

		group2.Construct(2);

		group1.DefaultOwningWindow();

		group2.DefaultOwningWindow();

		group1.DefaultOwningWindow();

		group1.Close();

		group2.Close();

		Client()->iWs.Flush();

		}

	else if (aKey.iCode=='w' || aKey.iCode=='W')

		{

		RWindowGroup group1(Client()->iWs);

		RWindowGroup group2(Client()->iWs);

		group1.Construct(1);

		group2.Construct(2);

		group1.DefaultOwningWindow();

		group2.DefaultOwningWindow();

		group1.DefaultOwningWindow();

		group2.Close();

		group1.Close();

		Client()->iWs.Flush();

		}

	else if (aKey.iCode=='A' || aKey.iCode=='a')

		{

		/*RWindowGroup group(Client()->iWs);

		group.Construct(1);*/

		RDrawableWindow* win=new(ELeave) RBackedUpWindow(Client()->iWs);

		User::LeaveIfError(((RBackedUpWindow*)win)->Construct(*Client()->iGroup->GroupWin(),EGray2,(TUint32)this));   

		User::LeaveIfError(win->SetExtentErr(TPoint(20,20),TSize(600,200)));

		win->Activate();

		}

	else if (aKey.iCode=='B' || aKey.iCode=='b')

		{

		RWindowGroup group(Client()->iWs);

		group.Construct(344);

		//group.EnableReceiptOfFocus(EFalse);

		RBlankWindow blank(Client()->iWs);

		blank.Construct(group,345);

		blank.SetOrdinalPosition(0,1000);

		//blank.SetShadowHeight(0);

		//blank.SetShadowDisabled(ETrue);

		blank.Activate();

		RWindow window(Client()->iWs);

		window.Construct(group,346);

		}

	/*else if (aKey.iCode=='Z' || aKey.iCode=='z')		//TDes8 TPtr8 TPtrC8 TBufCBase8 TBuf8

		{

		TBuf<4> buf2(_L("1234"));

		TBuf<4> buf(_L("abcd"));

		TBufC<4> bufC(_L("WXYZ"));

		HBufC *hbuf=HBufC::NewL(4);

		TPtr pHBuf=hbuf->Des();

		pHBuf=buf2;

		TPtr ptr(hbuf->Des());

		//AFunction(ptr);

		TPtrC ptrC1(buf);

		//AFunction(ptrC1);

		TPtrC ptrC2(bufC);

		//AFunction(ptrC2);

		TPtrC ptrC3(hbuf->Des());

		AFunction(ptrC3);

		AFunction(buf);

		AFunction(bufC);

		AFunction(*hbuf);

		AFunction2(ptr);

		AFunction2(buf);

		}*/

	if (aKey.iCode==' ')

		{

		iDrawPolygon=!iDrawPolygon;

		iWin.Invalidate();

		}

	}

TestWindow2::TestWindow2() : CTWin(),

		iWid(0), iFontHeight(16), iPointerState(EPointerOut), iFilter(0), iCapture(EFalse), iGrab(EFalse)

	{

	__DECLARE_NAME(_S("TestWindow2"));

	}

TestWindow2::~TestWindow2()

	{

	}

void TestWindow2::InitWinL()

	{

	iPos.SetXY(40,iFont->AscentInPixels()+10);

	TPoint next(0,iFont->HeightInPixels()+10);

	iPosBits=iPos+next;

	iPosMem=iPosBits+next;

	iWin.PointerFilter(0xFFFFFFFF,iFilter);

	User::LeaveIfError(iWin.EnableOnEvents());

	iWin.ClaimPointerGrab();

	}

void TestWindow2::Draw()

	{

	TInt pen=0;

	switch(iPointerState)

		{

		case EPointerIn:

			pen=0;

			break;

		case EPointerOut:

			pen=5;

			break;

		case EPointerUndefined:

			pen=15;

			break;

		}

	iGc->SetPenColor(TRgb::Gray16(pen));

	iGc->SetBrushColor(iBackColor);

	DrawBorder();

	iGc->DrawText(iBuf,iPos);

	iGc->DrawText(iBufBits,iPosBits);

	iGc->DrawText(iBufMem,iPosMem);

	}

void TestWindow2::NewText(TPoint &pos,TInt &width,TDes &des)

	{

	TInt newWid=iFont->TextWidthInPixels(des);

	Invalidate(TRect(pos-TSize(0,iFont->AscentInPixels()),pos+TSize(Max(width,newWid),iFont->DescentInPixels())));

	width=newWid;

	}

void TestWindow2::PointerState(EPointerState aState)

	{

	switch(aState)

		{

		case EPointerIn:

			iBackColor=TRgb::Gray16(15);

			break;

		case EPointerOut:

			iBackColor=TRgb::Gray16(12);

			break;

		case EPointerUndefined:

			iBackColor=TRgb::Gray16(4);

			break;

		}

	iWin.SetBackgroundColor(iBackColor);

	Invalidate();

	iPointerState=aState;

	}

void TestWindow2::SwitchOn(const TTime &)

	{

	iWin.SetBackgroundColor(TRgb(0,0,0));

	Client()->iWs.Flush();

	User::After(TTimeIntervalMicroSeconds32(500000));

	PointerState(iPointerState);

	}

void TestWindow2::PointerEnter(const TTime &)

	{

	PointerState(EPointerIn);

	}