// 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 the License "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:

 // e32\drivers\edisp\emul\win32\wd_wins.cpp

 // 

 //

 #include <e32cmn.h>

 #include <e32cmn_private.h>

 #include <emulator.h>

 #define WIN32_LEAN_AND_MEAN

 #pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

 #include <windows.h>

 #pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

 #include "ws_std.h"

 // Driver for WINS platform using windows stock font

 #define FONTWIDTH 8

 #define FONTHEIGHT 12

 struct rgbValues{

 	TUint8 iRed;

 	TUint8 iGreen;

 	TUint8 iBlue;

 	};

 const TUint8 KMonoRed0=50;

 const TUint8 KMonoGreen0=100;

 const TUint8 KMonoBlue0=200;

 const TUint8 KMonoRed1=250;

 const TUint8 KMonoGreen1=250;

 const TUint8 KMonoBlue1=20;

 const TColorIndex KMonoAttributes[8]=

     {

     1,      // Normal foreground

     0,      // Normal background

     1,      // Bold foreground

     0,      // Bold background

     0,      // Inverse foreground

     1,      // Inverse background

     0,      // Highlight foreground

     1       // Highlight background

     };

 const TColorIndex KColor256Attributes[8]=

     {

     38,      // Normal foreground

     33,      // Normal background

     36,      // Bold foreground

     38,      // Bold background

     33,      // Inverse foreground

     38,      // Inverse background

     38,      // Highlight foreground

     36       // Highlight background

     };

 class CScreenDriverWins : public CScreenDriver

 	{

 	friend class CScreenDriver;

 public:

 	CScreenDriverWins();

 	virtual void Init(TSize &aScreenSize,TSize &aFontSize);

 	virtual void Blit(const TText *aBuffer,TInt aLength,const TPoint &aPosition);

 	virtual TBool ScrollUp(const TRect& aRect);

 	virtual void Clear(const TRect& aRect);

 	virtual void SetPixel(const TPoint& aPoint,TUint8 aColour);

 	virtual TInt GetPixel(const TPoint& aPoint);

 	virtual void SetWord(const TPoint& aPoint,TInt aWord);

 	virtual TInt GetWord(const TPoint& aPoint);

 	virtual void SetLine(const TPoint& aPoint,const TPixelLine& aPixelLine);

 	virtual void GetLine(const TPoint& aPoint,TPixelLine& aPixelLine);

 	virtual void SetPaletteEntry(TColorIndex anIndex,TUint8 aRed,TUint8 aGreen,TUint8 aBlue);

 	virtual void GetPaletteEntry(TColorIndex anIndex,TUint8 &aRed,TUint8 &aGreen,TUint8 &aBlue);

 	virtual void SetForegroundColor(TColorIndex anIndex);

 	virtual void SetBackgroundColor(TColorIndex anIndex);

 	virtual void GetAttributeColors(TColorIndex* anArray);

 	virtual TInt SetMode(TVideoMode aMode);

 	static TBool IsHankaku(const TText aCode);

 	virtual TPoint GraphicsPosition(const TPoint& aPosition);

 	virtual void ScreenBufferScrollUp(const TRect& aRect);

 	virtual void ScreenBufferClear(const TRect& aRect);

 private:

     TText* iScreenBuffer;

 private:

 	HFONT iFont;

     HDC iDc;

 	TSize iTextScreenSize;

 	TScreenInfoV01 iScreenInfo;

 	TVideoMode iMode;

 	rgbValues* iPalette; 

 	};

 TPoint CScreenDriverWins::GraphicsPosition(const TPoint& aPosition)

 	{

     TPoint pos(0,aPosition.iY*FONTHEIGHT);

     TText* pS=iScreenBuffer+(iTextScreenSize.iWidth*aPosition.iY);

     TText* pE=pS+aPosition.iX;

 	for (TText* pT=pS;pT<pE;++pT)

 		pos.iX+=IsHankaku(*pT) ? FONTWIDTH : FONTWIDTH*2;

     return(pos);

 	}

 TBool CScreenDriverWins::IsHankaku(const TText aCode)

 	{

 	if (aCode >= 0xff61 && aCode <= 0xff9f) 

 		return ETrue;	// HANKAKU KATAKANA code

 	if (aCode >= 0x2550 && aCode <= 0x259f)

 		return ETrue;	// HANKAKU Graphics code

 	if (aCode < 0x100)

         return ETrue;	// Alphanumeric codes means HANKAKU

 	return EFalse;

 	}

 void CScreenDriverWins::ScreenBufferScrollUp(const TRect& aRect)

 	{

 	TText* src=&iScreenBuffer[(aRect.iTl.iY+1)*iTextScreenSize.iWidth+aRect.iTl.iX];

 	TText* dest=&iScreenBuffer[aRect.iTl.iY*iTextScreenSize.iWidth+aRect.iTl.iX];

 	for (TInt j=0;j<aRect.iBr.iY-aRect.iTl.iY;++j)

         {

 		TInt r=j*iTextScreenSize.iWidth;

 		for (TInt i=0;i<aRect.iBr.iX-aRect.iTl.iX+1;++i)

             {

 			TInt p = r+i;

 			dest[p] = src[p];

 			}

 		}

 	}

 void CScreenDriverWins::ScreenBufferClear(const TRect& aRect)

 	{

 	TText* dest=&iScreenBuffer[aRect.iTl.iY*iTextScreenSize.iWidth+aRect.iTl.iX];

 	for (TInt j=0;j<aRect.iBr.iY-aRect.iTl.iY+1;++j)

         {

 		TInt r=j*iTextScreenSize.iWidth;

 		for (TInt i=0;i<aRect.iBr.iX-aRect.iTl.iX+1;++i)

 			dest[r+i] = 0x0020;

 		}

 	}

 CScreenDriverWins::CScreenDriverWins()

 //

 // Constructor

 //

 	{

 	TPckg<TScreenInfoV01> sI(iScreenInfo);

 	UserSvr::ScreenInfo(sI);

 	iPalette=(rgbValues *)User::Alloc(256*sizeof(rgbValues));

 	}

 EXPORT_C CScreenDriver *CScreenDriver::New()

 //

 // Return the actual screen driver.

 //

 	{

 	CScreenDriverWins *pS=new CScreenDriverWins;

     if (!pS)

     	return(NULL);

 	if (!pS->iScreenInfo.iWindowHandleValid)

 		{

 		delete pS;

     	return(NULL);

 		}

     pS->iTextScreenSize=pS->iScreenInfo.iScreenSize;

 	pS->iTextScreenSize.iWidth/=FONTWIDTH; // Convert from GDI units to character positions

 	pS->iTextScreenSize.iHeight/=FONTHEIGHT;

     pS->iScreenBuffer=new TText[pS->iTextScreenSize.iWidth*pS->iTextScreenSize.iHeight];

     if (!pS->iScreenBuffer)

 		{

 		delete pS;

         return(NULL);

 		}

 	__LOCK_HOST;

 	HWND win=(HWND)pS->iScreenInfo.iWindowHandle;

 	pS->iDc=GetDC(win);

 	DWORD fontCharacterSet;

 	LANGID language;

 	fontCharacterSet=ANSI_CHARSET;

 	language=(LANGID)PRIMARYLANGID(GetSystemDefaultLangID());

 	if (language==LANG_JAPANESE) fontCharacterSet=SHIFTJIS_CHARSET;

 	pS->iFont=CreateFontA(FONTHEIGHT+1,      // logical font height

 						FONTWIDTH+1,        // logical average character width

 						0,                  // angle of escapement

 						0,                  // base-line orientation angle

 						FW_DONTCARE,        // font weight

 						0,                  // italic attribute

 						0,                  // underline attribute

 						0,                  // strikeout attribute

 				        fontCharacterSet,	// character set identifier

 						OUT_RASTER_PRECIS,  // output precision

 						CLIP_CHARACTER_PRECIS, // clipping precision

 						DEFAULT_QUALITY,    // output quality

 						FIXED_PITCH,        // pitch and family

 						"Terminal"          // typeface name string

 				        );

 	if (!pS->iFont)

 		{

 		delete pS->iScreenBuffer;

 		delete pS;

 		return(NULL);

 		}

 	// On some Windows9x PCs, the font we assume under NT isn't always present,

 	// but it's important we get a font with height 12.  Therefore increase the

 	// height setting and try again.  This seems always to do the trick.

 	TEXTMETRIC textMetrics;

 	HFONT oldFont=REINTERPRET_CAST(HFONT,SelectObject(pS->iDc,pS->iFont));

 	TBool tryNewFont=FALSE;

 	if (GetTextMetrics(pS->iDc, &textMetrics) && (textMetrics.tmHeight<12))

 		tryNewFont=TRUE;

 	SelectObject(pS->iDc, oldFont);

 	if (tryNewFont)

 		{

 		HFONT newFont=CreateFontA(FONTHEIGHT+2,

 							FONTWIDTH+1,

 							0,

 							0,

 							FW_DONTCARE,

 							0,

 							0,

 							0,

 							fontCharacterSet,

 							OUT_RASTER_PRECIS,

 							CLIP_CHARACTER_PRECIS,

 							DEFAULT_QUALITY,

 							FIXED_PITCH,

 							"Terminal"

 							);

 		if (newFont)

 			pS->iFont=newFont;

 		}

 	return(pS);

 	}

 void CScreenDriverWins::Init(TSize &aScreenSize,TSize &aFontSize)

 //

 // Report screen information

 //

 	{

 	aFontSize=TSize(FONTWIDTH,FONTHEIGHT);

 	aScreenSize=iTextScreenSize;

 	}

 TInt CScreenDriverWins::SetMode(TVideoMode aMode)

 //

 // Set the screen mode

 //

 	{

 //  Reset the palette

     if (aMode==EColor256)

         {

         TInt x, y, z, t;

     	for(t=0;t<16;t++)

     		{

     		iPalette[t].iRed=(TUint8)(t*8);

             iPalette[t].iGreen=(TUint8)(t*8);

             iPalette[t].iBlue=(TUint8)(t*8);

     		}

     	for(t=16;t<32;t++)

     		{

     		iPalette[t].iRed=(TUint8)(t*8+7);

             iPalette[t].iGreen=(TUint8)(t*8+7);

             iPalette[t].iBlue=(TUint8)(t*8+7);

     		}

     	for(x=0;x<2;x++)

     		for(y=0;y<2;y++)

     			for(z=0;z<2;z++)

     				{

     				iPalette[t].iRed=(TUint8)(x*255);

     				iPalette[t].iGreen=(TUint8)(y*255);

     				iPalette[t].iBlue=(TUint8)(z*255);

                     t++;

     				}

     	for(x=0;x<6;x++)

     		for(y=0;y<6;y++)

     			for(z=0;z<6;z++)

     				{

     				iPalette[t].iRed=(TUint8)(x*51);

     				iPalette[t].iGreen=(TUint8)(y*51);

     				iPalette[t].iBlue=(TUint8)(z*51);

                     t++;

     				}

         iMode=aMode;

         return(KErrNone);

         }

     if (aMode==EMono)

         {

         iPalette[0].iRed=KMonoRed0;

         iPalette[0].iGreen=KMonoGreen0;

         iPalette[0].iBlue=KMonoBlue0;

         iPalette[1].iRed=KMonoRed1;

         iPalette[1].iGreen=KMonoGreen1;

         iPalette[1].iBlue=KMonoBlue1;

         iMode=aMode;

         return(KErrNone);

         }

 	return(KErrNotSupported);

     }

 void CScreenDriverWins::Blit(const TText *aBuffer, TInt aLength, const TPoint &aPosition)

 //

 // Write contiguous block of characters to some segment of a line on the display

 //

 	{

 	if (iDc)

 	    {

         // Create a font of the appropriate metrics.  The character

         // set selection depends on the context.  The text console

         // was originally designed with the code page 850 line drawing

         // characters, so in the 8-bit version we continue to select

         // this, until we are in a position to supply a specific font

         // with the SDK.  In the 16-bit version, we can use an ANSI

         // font and the proper line drawing characters defined in Unicode.

         // For a Japanese environment, an attempt is made to select a

         // font that supports the shift-JIS character set.

 		__LOCK_HOST;

 		HFONT oldFont=REINTERPRET_CAST(HFONT,SelectObject(iDc,iFont));

 		if (oldFont)

 			{

 			TPtrC buf(aBuffer,aLength);

 			TBuf<0x100> b;

 			b.Copy(buf);

 			TText* code =(TText*)b.Ptr();

             Mem::Copy(iScreenBuffer+((aPosition.iY*iTextScreenSize.iWidth)+aPosition.iX),code,aLength*2);

 			TPoint ap=GraphicsPosition(aPosition);

 			for (TInt i=0;i<aLength;++i)

 				{

 				TInt fontWidth = IsHankaku(*code) ? FONTWIDTH : FONTWIDTH*2;

 				RECT rect;

 				SetRect(&rect, ap.iX, ap.iY, ap.iX + fontWidth, ap.iY + FONTHEIGHT);

 				// The following function is better than TextOutW because it will fill in the gaps

 				// if we get a font smaller than the appropriate size.

 				ExtTextOutW(iDc, ap.iX, ap.iY, ETO_OPAQUE, &rect, (const unsigned short *)code, 1, NULL);

 				ap.iX+=fontWidth;

 				code++;

 				}

 			SelectObject(iDc,oldFont);

 			}

 		GdiFlush();

 		}

 	}

 TBool CScreenDriverWins::ScrollUp(const TRect& aRect)

 //

 // Scroll a rectangle of the screen up one line, the bottom line is not updated, return ETrue on sucess

 //

 	{

 	ScreenBufferScrollUp(aRect);

 	// Create MSVC RECT from E32 TRect

 	__LOCK_HOST;

 	RECT rect;

 	rect.left=(aRect.iTl.iX)*FONTWIDTH;

 	rect.top=(aRect.iTl.iY+1)*FONTHEIGHT;

 	rect.right=(aRect.iBr.iX)*FONTWIDTH;

 	rect.bottom=(aRect.iBr.iY)*FONTHEIGHT;

 	RECT updateRect;

 	ScrollWindowEx((HWND)iScreenInfo.iWindowHandle,0,-FONTHEIGHT,&rect,NULL,NULL,&updateRect,0);

 	GdiFlush();

 	if (updateRect.bottom==0 || (rect.bottom==updateRect.bottom && updateRect.bottom==updateRect.top+FONTHEIGHT))

 		return ETrue;

 	return EFalse;

 	}

 void CScreenDriverWins::Clear(const TRect& aRect)

 //

 // Clear a rectangle of the screen

 //

 	{

 	ScreenBufferClear(aRect);

 	// Create MSVC RECT from E32 TRect

 	__LOCK_HOST;

 	RECT rect;

 	rect.left=(aRect.iTl.iX)*FONTWIDTH;

 	rect.top=(aRect.iTl.iY)*FONTHEIGHT;

 	rect.right=(aRect.iBr.iX)*FONTWIDTH;

 	rect.bottom=(aRect.iBr.iY)*FONTHEIGHT;

 	FillRect(GetDC((HWND)iScreenInfo.iWindowHandle),&rect,NULL); 

 	GdiFlush();

 	}

 void CScreenDriverWins::SetPaletteEntry(TColorIndex anIndex,TUint8 aRed,TUint8 aGreen,TUint8 aBlue)

 	{

 	if(iMode==EColor256)

 		{

 		iPalette[anIndex].iRed=aRed;iPalette[anIndex].iGreen=aGreen;iPalette[anIndex].iBlue=aBlue;

 		}

 	}

 void CScreenDriverWins::GetPaletteEntry(TColorIndex anIndex,TUint8 &aRed,TUint8 &aGreen,TUint8 &aBlue)

 	{

 	aRed=iPalette[anIndex].iRed;aGreen=iPalette[anIndex].iGreen;aBlue=iPalette[anIndex].iBlue;

 	}

 void CScreenDriverWins::SetForegroundColor(TColorIndex anIndex)

 	{

 	__LOCK_HOST;

     TInt index=anIndex;

 	index=Min(index,(1<<iMode)-1);

 	SetTextColor(iDc,RGB(iPalette[index].iRed,iPalette[index].iGreen,iPalette[index].iBlue));

 	GdiFlush();

 	}

 void CScreenDriverWins::SetBackgroundColor(TColorIndex anIndex)

 	{

 	__LOCK_HOST;

     TInt index=anIndex;

 	index=Min(index,(1<<iMode)-1);

 	SetBkColor(iDc,RGB(iPalette[index].iRed,iPalette[index].iGreen,iPalette[index].iBlue));

 	GdiFlush();

 	}

 void CScreenDriverWins::GetAttributeColors(TColorIndex* anArray)

 //

 //

 //

 	{

 	if(iMode==EMono)

         Mem::Copy(anArray,KMonoAttributes,sizeof(KMonoAttributes));

 	else if(iMode==EColor256)

         Mem::Copy(anArray,KColor256Attributes,sizeof(KColor256Attributes));

 	}

 void CScreenDriverWins::SetPixel(const TPoint& /*aPoint*/,TUint8 /*aColour*/)

 	{

 	}

 TInt CScreenDriverWins::GetPixel(const TPoint& /*aPoint*/)

 	{

 	return 0;

 	}

 void CScreenDriverWins::SetWord(const TPoint& /*aPoint*/,TInt /*aWord*/)

 	{

 	}

 TInt CScreenDriverWins::GetWord(const TPoint& /*aPoint*/)

 	{

 	return 0;

 	}

 void CScreenDriverWins::SetLine(const TPoint& /*aPoint*/,const TPixelLine& /*aPixelLine*/)

 	{

 	}

 void CScreenDriverWins::GetLine(const TPoint& /*aPoint*/,TPixelLine& /*aPixelLine*/)

 	{

 	}