// view.cpp
//
// Copyright (c) 2003 Symbian Ltd.  All rights reserved.

#include "engine.h"
#include "view.h"
#include "appui.h"


#include <quartzkeys.h>

#include <gulutil.h>
#include <eikenv.h>
#include <eikmenub.h>

// fleet view

const TInt KTileSizeInTwips=480; // 1/3"
const TInt KBorderSizeInTwips=240; // 1/6"
const TInt KIdealBoardSizeInTwips=8*KTileSizeInTwips + 2*KBorderSizeInTwips; // 3"

CFleetViewData::CFleetViewData(CSoundEffects& aSoundEffects, 
	MGameViewCmdHandler& aCmdHandler,
	const TRect& aRect)
	:iSoundEffects(aSoundEffects), iCmdHandler(aCmdHandler), iClientRect(aRect)
	{
	iRect = iClientRect;
	iRect.Move(-iRect.iTl.iX, -iRect.iTl.iY);
	iEnv=CEikonEnv::Static();
	}

void CFleetViewData::ConstructL()
	{
	// Set zoom factor
	SetZoomL(1000);
	}
	
void CFleetViewData::SetZoomL(TInt aZoomFactor)
	{
	// check we're doing something useful
	if (iZoomFactor==aZoomFactor)
		return;
	iZoomFactor=aZoomFactor;
	// find available size in pixels
	TInt boardSize=iRect.Width() < iRect.Height() ? iRect.Width() : iRect.Height();
	// calculate board size in twips, and hence scale factor
	TInt boardSizeInTwips=iEnv->ScreenDevice()->HorizontalPixelsToTwips(boardSize);
	boardSizeInTwips=(boardSizeInTwips * iZoomFactor) / 1000; // zoom
	TInt scaleFactor=(boardSizeInTwips * 1000) / KIdealBoardSizeInTwips;
	boardSize=iEnv->ScreenDevice()->HorizontalTwipsToPixels(boardSizeInTwips);
	// tile and border sizes also
	TInt tileSizeInTwips=(KTileSizeInTwips*scaleFactor) / 1000;
	TInt borderSizeInTwips=(KBorderSizeInTwips*scaleFactor) / 1000;
	// calculate tile and border sizes in pixels, ensuring even distribution
	iBorderSize=iEnv->ScreenDevice()->HorizontalTwipsToPixels(borderSizeInTwips);
	iTileSize=(boardSize-iBorderSize*2)/8; // eighth remaining, rounding down
	TInt innerSize=iTileSize*8; // whole size of inner region
	iBorderSize=(boardSize-innerSize)/2; // adjust border size again
	boardSize=innerSize+iBorderSize*2; // final board size
	// pre-calculate actual rectangles for everything
	iBoardRect=TRect(0,0,boardSize,boardSize);
	iTopBorder=TRect(0,0,boardSize,iBorderSize);
	iBottomBorder=TRect(0,iBorderSize+innerSize,boardSize,boardSize);
	iLeftBorder=TRect(0,iBorderSize,iBorderSize,iBorderSize+innerSize);
	iRightBorder=TRect(iBorderSize+innerSize,iBorderSize,boardSize,iBorderSize+innerSize);
	iSeaArea=TRect(iBorderSize,iBorderSize,iBorderSize+innerSize,iBorderSize+innerSize);
	// offset everything to center properly
	TPoint offset(
		iRect.iTl.iX+(iRect.Width()-boardSize)/2,
		iRect.iTl.iY+(iRect.Height()-boardSize)/2);
	iBoardRect.Move(offset);
	iTopBorder.Move(offset);
	iBottomBorder.Move(offset);
	iLeftBorder.Move(offset);
	iRightBorder.Move(offset);
	iSeaArea.Move(offset);
	// get small font for drawing border
	TFontSpec specBorder(_L("Arial"), (borderSizeInTwips*3)/4);
	specBorder.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
	CFont* borderFont=iEnv->CreateScreenFontL(specBorder);
	if (iBorderFont)
		iEnv->ReleaseScreenFont(iBorderFont);
	iBorderFont=borderFont;
	// larger font for drawing tiles
	TFontSpec specTile(_L("Arial"), (tileSizeInTwips*3)/4);
	specTile.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
	CFont* tileFont=iEnv->CreateScreenFontL(specTile);
	if (iTileFont)
		iEnv->ReleaseScreenFont(iTileFont);
	iTileFont=tileFont;	
	}

CFleetViewData::~CFleetViewData()
	{
	// Release fonts
	iEnv->ReleaseScreenFont(iTileFont);
	iEnv->ReleaseScreenFont(iBorderFont);
	}
	
/*
TInt CFleetView::GetZoom() const
	{
	return iZoomFactor;
	}
*/

CFleetView::CFleetView(CFleetViewData& aFleetViewData, TFleet& aFleet)
	:iData(aFleetViewData), iFleet(aFleet)
	{
	}
	
void CFleetView::ConstructL()
	{
	CreateWindowL();
	SetRect(iData.iClientRect);
	SetCursor(0,0);
	// Add to the registered views
	iEikonEnv->EikAppUi()->RegisterViewL(*this);
	iEikonEnv->EikAppUi()->AddToStackL(*this, this);
	// Set ready for drawing
	ActivateL(); 
	}

CFleetView::~CFleetView()
	{
	// Remove from registered views
	iEikonEnv->EikAppUi()->RemoveFromStack(this);
	iEikonEnv->EikAppUi()->DeregisterView(*this);
	}
	
// incremental drawing

void CFleetView::DrawTilesNow() const
	{
	
	//User::InfoPrint(_L("CFleetView::DrawTilesNow()"));
	//User::After(2000000);

	_LIT(KViewId, "DrawTilesNow UID = %d");
	TBuf<100> bView;
	bView.Format(KViewId, iViewUid.iUid);
	//User::InfoPrint(bView);
	//User::After(3000000);
	
	
	
	
	
	CFleetViewData* pView = &iData;
	if (pView)
		{
		//User::InfoPrint(_L("iData OK"));
		//User::After(2000000);
		}
	else
		{
		//User::InfoPrint(_L("iData NOT OK"));
		//User::After(2000000);
		}	
	
	Window().Invalidate(iData.iSeaArea);
	ActivateGc();
	Window().BeginRedraw(iData.iSeaArea);
	DrawTiles();
	Window().EndRedraw();
	DeactivateGc();
	}

// from CCoeControl

void CFleetView::Draw(const TRect&) const
	{
	DrawOutside();
	DrawBorders();
	DrawTiles();
	}

// auxiliary drawing functions

void CFleetView::DrawOutside() const
	{
	CWindowGc& gc=SystemGc();
	gc.SetPenStyle(CGraphicsContext::ENullPen);
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.SetBrushColor(KRgbWhite);
	DrawUtils::DrawBetweenRects(gc, iData.iRect, iData.iBoardRect);	
	}

void CFleetView::DrawBorders() const
	{
	DrawHorizontalBorder(iData.iTopBorder);
	DrawHorizontalBorder(iData.iBottomBorder);
	DrawVerticalBorder(iData.iLeftBorder);
	DrawVerticalBorder(iData.iRightBorder);
	}

void CFleetView::DrawHorizontalBorder(const TRect& aRect) const
	{
	CWindowGc& gc = SystemGc();
	// draw corners - in fact, whole border
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.SetBrushColor(KRgbBlack);
	gc.SetPenStyle(CGraphicsContext::ENullPen);
	gc.DrawRect(aRect);
	// draw letters
	gc.SetPenStyle(CGraphicsContext::ESolidPen);
	gc.SetPenColor(KRgbWhite);
	_LIT(KBorderLetters,"ABCDEFGH");
	gc.UseFont(iData.iBorderFont);
	for (TInt i=0; i<8; i++)
		{
		TRect rect(
			aRect.iTl.iX+iData.iBorderSize+i*iData.iTileSize, aRect.iTl.iY,
			aRect.iTl.iX+iData.iBorderSize+(i+1)*iData.iTileSize, aRect.iBr.iY
			);
		TPtrC text=KBorderLetters().Mid(i,1);
		TInt baseline=rect.Height()/2 + iData.iBorderFont->AscentInPixels()/2;
		gc.DrawText(text, rect, baseline, CGraphicsContext::ECenter);
		}
	gc.DiscardFont();
	}

void CFleetView::DrawVerticalBorder(const TRect& aRect) const
	{
	CWindowGc& gc = SystemGc();
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.SetBrushColor(IsDimmed() ? KRgbGray : KRgbBlack);
	gc.SetPenStyle(CGraphicsContext::ESolidPen);
	gc.SetPenColor(KRgbWhite);
	_LIT(KBorderLetters,"12345678");
	gc.UseFont(iData.iBorderFont);
	for (TInt i=0; i<8; i++)
		{
		TRect rect(
			aRect.iTl.iX, aRect.iTl.iY+i*iData.iTileSize,
			aRect.iBr.iX, aRect.iTl.iY+(i+1)*iData.iTileSize
			);
		TPtrC text=KBorderLetters().Mid(i,1);
		TInt baseline=rect.Height()/2 + iData.iBorderFont->AscentInPixels()/2;
		gc.DrawText(text, rect, baseline, CGraphicsContext::ECenter);
		}
	gc.DiscardFont();
	}

void CFleetView::DrawTiles() const
	{
	CWindowGc& gc = SystemGc();
	gc.UseFont(iData.iTileFont);
	for (TInt x=0; x<8; x++)
		for (TInt y=0; y<8; y++)
			DrawTile(x,y);
	gc.DiscardFont();
	}

void CFleetView::DrawTile(TInt aX, TInt aY) const
	{
	CWindowGc& gc = SystemGc();
	TRect rect(
		iData.iSeaArea.iTl.iX+aX*iData.iTileSize, iData.iSeaArea.iTl.iY+aY*iData.iTileSize,
		iData.iSeaArea.iTl.iX+(aX+1)*iData.iTileSize, iData.iSeaArea.iTl.iY+(aY+1)*iData.iTileSize
		);
		
	// set background colour depending on whether known, hit or otherwise
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	if (!iFleet.IsKnown(aX,aY))
		gc.SetBrushColor(KRgbWhite);
	else if (iFleet.IsHit(aX,aY))
		gc.SetBrushColor(KRgbDarkRed);
	else gc.SetBrushColor(KRgbCyan);

	// draw either plain square or text
	if (iFleet.IsShip(aX,aY))
		{
		// set pen colour depending on whether hit or not
		gc.SetPenStyle(CGraphicsContext::ESolidPen);
		if (iFleet.IsHit(aX,aY))
			gc.SetPenColor(KRgbYellow);
		else
			gc.SetPenColor(KRgbBlack);
		// set character depending on ship and ship type
		TPtrC text;
		_LIT(kShips,"BCDF");
		text.Set(kShips().Mid(iFleet.ShipType(aX,aY)-TShip::EBattleship,1));
		// draw the square
		TInt baseline=rect.Height()/2 + iData.iTileFont->AscentInPixels()/2;
		gc.DrawText(text, rect, baseline, CGraphicsContext::ECenter);
		}