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

// bootldr\src\display\display.cpp

// 

//

#define FILE_ID	0x44495350

#define DEFINE_COLOURS

//

// Defining ENABLE_TRANSFER_STATS will display simplistic average and point

// transfer rates in bytes per second and provide an estimate of the length of

// time remaining.

//

#define ENABLE_TRANSFER_STATS

#include "bootldr.h"

#include <videodriver.h>

#include <hal.h>

TUint8* Screen;

TInt Screenwidth, Screenheight;		// screen dimentions in pixels

TInt XPos;

TInt YPos;

TUint Colours;

TUint PixelSize = 1;	// size of a pixel in bytes

TUint Progress[2];

TUint Pixels[2];

TUint Limit[2];

TUint32 ProgressTime[2];

TUint32 StartTime;

// Palette entries are in the platform's config.h

const TUint16 Palette[16]=	{

		KPaletteEntBlack		| KPaletteEntPBS,

		KPaletteEntMidBlue,		// 1

		KPaletteEntMidGreen,	// 2

		KPaletteEntMidCyan,		// 3

		KPaletteEntMidRed,		// 4

		KPaletteEntMidMagenta,	// 5

		KPaletteEntMidYellow,	// 6

		KPaletteEntDimWhite,	// 7

		KPaletteEntGray,		// 8

		KPaletteEntBlue,		// 9

		KPaletteEntGreen,		// 10 A

		KPaletteEntCyan,		// 11 B

		KPaletteEntRed,			// 12 C

		KPaletteEntMagenta,		// 13 D

		KPaletteEntYellow,		// 14 E

		KPaletteEntWhite 		// 15 F

		};

const TUint KRgbBlack		= 0x000000;

//const TUint KRgbDarkGray	= 0x555555;

const TUint KRgbDarkRed		= 0x800000;

const TUint KRgbDarkGreen	= 0x008000;

const TUint KRgbDarkYellow	= 0x808000;

const TUint KRgbDarkBlue	= 0x000080;

const TUint KRgbDarkMagenta	= 0x800080;

const TUint KRgbDarkCyan	= 0x008080;

const TUint KRgbRed			= 0xFF0000;

//const TUint KRgbGreen		= 0x00FF00;

const TUint KRgbYellow		= 0xFFFF00;

const TUint KRgbBlue		= 0x0000FF;

const TUint KRgbMagenta		= 0xFF00FF;

const TUint KRgbCyan		= 0x00FFFF;

const TUint KRgbGray		= 0xAAAAAA;

const TUint KRgbWhite		= 0xFFFFFF;

const TUint KRgbDimWhite    = 0xCCCCCC;

const TUint32 Palette32[16] =

{

    KRgbBlack,       // 0

    KRgbDarkBlue,    // 1

    KRgbDarkGreen,   // 2

    KRgbDarkCyan,    // 3

    KRgbDarkRed,     // 4

    KRgbDarkMagenta, // 5

    KRgbDarkYellow,  // 6

    KRgbDimWhite,    // 7 KRgbDarkGray()

    KRgbGray,        // 8

    KRgbBlue,        // 9

    KRgbDarkGreen,   // 10

    KRgbCyan,        // 11

    KRgbRed,         // 12

    KRgbMagenta,     // 13

    KRgbYellow,      // 14

    KRgbWhite        // 15

};

// KForeground, Kbackground and [I]Pcolour entries are indexes into the palette.

// The progress bar colours are of the form "(foreground << 8) | background"

const TUint8 KForeground = 15;

const TUint8 KBackground = 9;

const TUint PColour[2]={ 0xa08, 0xc08 };		//	(10|8) and (12|8)

const TUint IPColour[2]={ 0x809, 0x809 };		//	(8|9) and (8|9)

#define NUM_FONTS	96

#define FONT_HEIGHT	10

#define FONT_WIDTH	8

#define SCREEN_SIZE			(Screenheight*Screenwidth*PixelSize)			// number of pixels (size in bytes)

#define MAX_COLUMN			(Screenwidth/FONT_WIDTH)			// chars per line e.g. 80 or 40

#define MAX_ROW				(Screenheight/FONT_HEIGHT)			// lines per screen e.g. 48 or 24

#define PROGRESSBAR0_ROW	(MAX_ROW-1)							// row in which to draw progress bar 0

#define PROGRESSBAR1_ROW	(MAX_ROW-2)							// row in which to draw progress bar 1

#define STATS_ROW			(MAX_ROW-3)							// DEBUGGING row in which to write eta/bps

//

// ascii character code - 32 == character index into bootldr table

//

extern const TUint8 Font[NUM_FONTS][FONT_HEIGHT] =

 	{

		{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x30,0x78,0x78,0x78,0x30,0x00,0x30,0x00,0x00,0x00},	//!

		{0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x6C,0x6C,0xFE,0x6C,0xFE,0x6C,0x6C,0x00,0x00,0x00},	//#

		{0x30,0x7C,0xC0,0x78,0x0C,0xF8,0x30,0x00,0x00,0x00},	//$

		{0x00,0xC6,0xCC,0x18,0x30,0x66,0xC6,0x00,0x00,0x00},

		{0x38,0x6C,0x38,0x76,0xDC,0xCC,0x76,0x00,0x00,0x00},

		{0x60,0x60,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x18,0x30,0x60,0x60,0x60,0x30,0x18,0x00,0x00,0x00},

		{0x60,0x30,0x18,0x18,0x18,0x30,0x60,0x00,0x00,0x00},

		{0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00,0x00,0x00},

		{0x00,0x30,0x30,0xFC,0x30,0x30,0x00,0x00,0x00,0x00},

		{0x00,0x00,0x00,0x00,0x00,0x30,0x30,0x60,0x00,0x00},

		{0x00,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00},	//-

		{0x00,0x00,0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00},	//.

		{0x06,0x0C,0x18,0x30,0x60,0xC0,0x80,0x00,0x00,0x00},	///

		{0x7C,0xC6,0xCE,0xDE,0xF6,0xE6,0x7C,0x00,0x00,0x00},	//0

		{0x30,0x70,0x30,0x30,0x30,0x30,0xFC,0x00,0x00,0x00},

		{0x78,0xCC,0x0C,0x38,0x60,0xCC,0xFC,0x00,0x00,0x00},

		{0x78,0xCC,0x0C,0x38,0x0C,0xCC,0x78,0x00,0x00,0x00},

		{0x1C,0x3C,0x6C,0xCC,0xFE,0x0C,0x1E,0x00,0x00,0x00},

		{0xFC,0xC0,0xF8,0x0C,0x0C,0xCC,0x78,0x00,0x00,0x00},

		{0x38,0x60,0xC0,0xF8,0xCC,0xCC,0x78,0x00,0x00,0x00},

		{0xFC,0xCC,0x0C,0x18,0x30,0x30,0x30,0x00,0x00,0x00},

		{0x78,0xCC,0xCC,0x78,0xCC,0xCC,0x78,0x00,0x00,0x00},

		{0x78,0xCC,0xCC,0x7C,0x0C,0x18,0x70,0x00,0x00,0x00},	//9

		{0x00,0x30,0x30,0x00,0x00,0x30,0x30,0x00,0x00,0x00},	//:

		{0x00,0x30,0x30,0x00,0x00,0x30,0x30,0x60,0x00,0x00},	//;

		{0x18,0x30,0x60,0xC0,0x60,0x30,0x18,0x00,0x00,0x00},	//<

		{0x00,0x00,0xFC,0x00,0x00,0xFC,0x00,0x00,0x00,0x00},	//=

		{0x60,0x30,0x18,0x0C,0x18,0x30,0x60,0x00,0x00,0x00},	//>

		{0x78,0xCC,0x0C,0x18,0x30,0x00,0x30,0x00,0x00,0x00},	//?

		{0x7C,0xC6,0xDE,0xDE,0xDE,0xC0,0x78,0x00,0x00,0x00},	//@

		{0x30,0x78,0xCC,0xCC,0xFC,0xCC,0xCC,0x00,0x00,0x00},	//A

		{0xFC,0x66,0x66,0x7C,0x66,0x66,0xFC,0x00,0x00,0x00},	//B

		{0x3C,0x66,0xC0,0xC0,0xC0,0x66,0x3C,0x00,0x00,0x00},	//C

		{0xF8,0x6C,0x66,0x66,0x66,0x6C,0xF8,0x00,0x00,0x00},	//D

		{0x7E,0x60,0x60,0x78,0x60,0x60,0x7E,0x00,0x00,0x00},	//E

		{0x7E,0x60,0x60,0x78,0x60,0x60,0x60,0x00,0x00,0x00},	//F

		{0x3C,0x66,0xC0,0xC0,0xCE,0x66,0x3E,0x00,0x00,0x00},	//G

		{0xCC,0xCC,0xCC,0xFC,0xCC,0xCC,0xCC,0x00,0x00,0x00},	//H

		{0x78,0x30,0x30,0x30,0x30,0x30,0x78,0x00,0x00,0x00},	//I

		{0x1E,0x0C,0x0C,0x0C,0xCC,0xCC,0x78,0x00,0x00,0x00},	//J

		{0xE6,0x66,0x6C,0x78,0x6C,0x66,0xE6,0x00,0x00,0x00},	//K

		{0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,0x00,0x00},	//L

		{0xC6,0xEE,0xFE,0xFE,0xD6,0xC6,0xC6,0x00,0x00,0x00},	//M

		{0xC6,0xE6,0xF6,0xDE,0xCE,0xC6,0xC6,0x00,0x00,0x00},	//N

		{0x38,0x6C,0xC6,0xC6,0xC6,0x6C,0x38,0x00,0x00,0x00},	//O

		{0xFC,0x66,0x66,0x7C,0x60,0x60,0xF0,0x00,0x00,0x00},	//P

		{0x78,0xCC,0xCC,0xCC,0xDC,0x78,0x1C,0x00,0x00,0x00},	//Q

		{0xFC,0x66,0x66,0x7C,0x6C,0x66,0xE6,0x00,0x00,0x00},	//R

		{0x78,0xCC,0xE0,0x70,0x1C,0xCC,0x78,0x00,0x00,0x00},	//S

		{0xFC,0x30,0x30,0x30,0x30,0x30,0x30,0x00,0x00,0x00},	//T

		{0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFC,0x00,0x00,0x00},	//U

		{0xCC,0xCC,0xCC,0xCC,0xCC,0x78,0x30,0x00,0x00,0x00},	//V

		{0xC6,0xC6,0xC6,0xD6,0xFE,0xEE,0xC6,0x00,0x00,0x00},	//W

		{0xC6,0xC6,0x6C,0x38,0x38,0x6C,0xC6,0x00,0x00,0x00},	//X

		{0xCC,0xCC,0xCC,0x78,0x30,0x30,0x78,0x00,0x00,0x00},	//Y

		{0xFE,0x06,0x0C,0x18,0x30,0x60,0xFE,0x00,0x00,0x00},	//Z

		{0x78,0x60,0x60,0x60,0x60,0x60,0x78,0x00,0x00,0x00},

		{0xC0,0x60,0x30,0x18,0x0C,0x06,0x02,0x00,0x00,0x00},

		{0x78,0x18,0x18,0x18,0x18,0x18,0x78,0x00,0x00,0x00},

		{0x10,0x38,0x6C,0xC6,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00},

		{0x30,0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x00,0x00,0x78,0x0C,0x7C,0xCC,0x76,0x00,0x00,0x00},

		{0xE0,0x60,0x60,0x7C,0x66,0x66,0xDC,0x00,0x00,0x00},

		{0x00,0x00,0x78,0xCC,0xC0,0xCC,0x78,0x00,0x00,0x00},

		{0x1C,0x0C,0x0C,0x7C,0xCC,0xCC,0x76,0x00,0x00,0x00},

		{0x00,0x00,0x78,0xCC,0xFC,0xC0,0x78,0x00,0x00,0x00},

		{0x38,0x6C,0x60,0xF0,0x60,0x60,0xF0,0x00,0x00,0x00},

		{0x00,0x00,0x76,0xCC,0xCC,0x7C,0x0C,0xF8,0x00,0x00},

		{0xE0,0x60,0x6C,0x76,0x66,0x66,0xE6,0x00,0x00,0x00},

		{0x30,0x00,0x70,0x30,0x30,0x30,0x78,0x00,0x00,0x00},

		{0x0C,0x00,0x0C,0x0C,0x0C,0xCC,0xCC,0x78,0x00,0x00},

		{0xE0,0x60,0x66,0x6C,0x78,0x6C,0xE6,0x00,0x00,0x00},

		{0x70,0x30,0x30,0x30,0x30,0x30,0x78,0x00,0x00,0x00},

		{0x00,0x00,0xCC,0xFE,0xFE,0xD6,0xC6,0x00,0x00,0x00},

		{0x00,0x00,0xF8,0xCC,0xCC,0xCC,0xCC,0x00,0x00,0x00},

		{0x00,0x00,0x78,0xCC,0xCC,0xCC,0x78,0x00,0x00,0x00},

		{0x00,0x00,0xDC,0x66,0x66,0x7C,0x60,0xF0,0x00,0x00},

		{0x00,0x00,0x76,0xCC,0xCC,0x7C,0x0C,0x1E,0x00,0x00},

		{0x00,0x00,0xDC,0x76,0x66,0x60,0xF0,0x00,0x00,0x00},

		{0x00,0x00,0x7C,0xC0,0x78,0x0C,0xF8,0x00,0x00,0x00},

		{0x10,0x30,0x7C,0x30,0x30,0x34,0x18,0x00,0x00,0x00},

		{0x00,0x00,0xCC,0xCC,0xCC,0xCC,0x76,0x00,0x00,0x00},

		{0x00,0x00,0xCC,0xCC,0xCC,0x78,0x30,0x00,0x00,0x00},

		{0x00,0x00,0xC6,0xD6,0xFE,0xFE,0x6C,0x00,0x00,0x00},

		{0x00,0x00,0xC6,0x6C,0x38,0x6C,0xC6,0x00,0x00,0x00},

		{0x00,0x00,0xCC,0xCC,0xCC,0x7C,0x0C,0xF8,0x00,0x00},

		{0x00,0x00,0xFC,0x98,0x30,0x64,0xFC,0x00,0x00,0x00},

		{0x1C,0x30,0x30,0xE0,0x30,0x30,0x1C,0x00,0x00,0x00},

		{0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x00,0x00},

		{0xE0,0x30,0x30,0x1C,0x30,0x30,0xE0,0x00,0x00,0x00},

		{0x76,0xDC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},

		{0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00},

	};

inline void ColourPixel(TInt aXPos, TInt aYPos, TUint aColour)

/**

colour a pixel on the screen

@param aXPos	pixel's X coordinate

@param aYPos	pixel's Y coordinate

@param aColour	chosen colour specified as a palette index

*/

{

	TUint8* pV = (TUint8*)Screen + (aYPos * (Screenwidth * PixelSize)) + (aXPos * PixelSize);

	switch(PixelSize)

		{

		case 4:

			*(TUint32*)pV = Palette32[aColour];

			break;

		case 2:

			*pV++ = Palette[aColour] & 0xFF ;

			*pV = Palette[aColour] >> 8 ;

			break;

		case 1:

			*pV = aColour;

			break;

		default:

			// Kern::Fault("BOOTLDR colourpixel: Unsupported bpp", PixelSize);

			BOOT_FAULT();

		}

}

#ifndef USE_ASM_DISPLAYCHAR

void DisplayChar(TInt aChar, TInt aXPos, TInt aYPos, TUint aColours)

/**

Write a character to the framebuffer

@param aChar	Character to draw

@param aXPos	Character's column

@param aYPos	Character's row

@param aColour	Palette index specified (foreground << 8| background)

*/

	{

	// Convert the ascii value into an index for the Font table

	TInt tmpChar = aChar - 32;

	// Validate this is a valid font index

	if (tmpChar < 0 || tmpChar >= NUM_FONTS)

		return;

	// Validate coordinates lie within range.

	if (aXPos > MAX_COLUMN-1 || aYPos > MAX_ROW-1)

		return;

	// for each line of the font

	for (TUint line=0 ; line < FONT_HEIGHT ; line++)

		{

		TUint8 tmpLine = Font[tmpChar][line];

		TUint8 tmpMask = 0x80;

		// for each pixel of the line

		for (TUint pixel=0 ; pixel < FONT_WIDTH ; pixel++)

			{

			ColourPixel(aXPos * FONT_WIDTH + pixel,

						aYPos * FONT_HEIGHT + line,

						(tmpLine & tmpMask) ? aColours >> 8 : aColours & 0xFF);

			// Shift the mask one bit downward to examine the next pixel

			tmpMask = tmpMask >> 1;

			}

		}

	return;

	}

#endif

GLDEF_C void ClearScreen()

/**

Set all the pixels on the screen to the background

*/

	{

	for (TInt y = 0 ; y<Screenheight ; y++)

		for (TInt x = 0 ; x<Screenwidth ; x++)

			ColourPixel(x, y, KBackground);

	XPos=0;

	YPos=0;

	Colours=(KForeground<<8)|KBackground;

	}

void ScrollScreen()

/**

Move all the pixels in the scrolling text area up one line and fill the

last line with the background colour

*/

	{

	TUint8* pV=Screen;

	wordmove(pV, pV+(Screenwidth*PixelSize*FONT_HEIGHT), (Screenwidth*PixelSize*(Screenheight-(2*FONT_HEIGHT))-(Screenwidth*PixelSize*FONT_HEIGHT)));

	pV+=(Screenwidth*PixelSize*(Screenheight-(2*FONT_HEIGHT))-(Screenwidth*PixelSize*FONT_HEIGHT));

	TInt StartLine = (Screenheight-(4*FONT_HEIGHT));

	for (TInt y = StartLine ; y<(StartLine+FONT_HEIGHT) ; y++)

		for (TInt x = 0 ; x<Screenwidth ; x++)

			ColourPixel(x, y, KBackground);

	}

void ScrollScreenDown()

/**

Move all the pixels in the scrolling text area down one line and fill the

first line with the background colour

*/

	{

	TUint8* pV=Screen;

	wordmove(pV+(Screenwidth*PixelSize*FONT_HEIGHT), pV, (Screenwidth*PixelSize*(Screenheight-(2*FONT_HEIGHT))-(Screenwidth*PixelSize*FONT_HEIGHT)));

	for (TInt y = 0 ; y<FONT_HEIGHT ; y++)

		for (TInt x = 0 ; x<Screenwidth ; x++)

			ColourPixel(x, y, KBackground);

	}

void CurDown()

/**

Move the cursor down the screen, scrolling the text area if necessary

*/

	{

	if (++YPos==(MAX_ROW-3))

		{

		YPos=(MAX_ROW-4);

		ScrollScreen();

		}

	}

void CurUp()

/**

Move the cursor up the screen, scrolling the text area if necessary

*/

	{

	if (--YPos<0)

		{

		YPos=0;

		ScrollScreenDown();

		}

	}

void CurRight()

/**

Move the cursor along the screen, scrolling the text area if necessary

*/

	{

	if (++XPos==MAX_COLUMN)

		{

		XPos=0;

		CurDown();

		}

	}

void CurLeft()

/**

Move the cursor backwards along the screen, scrolling the text area if necessary

*/

	{

	if (--XPos<0)

		{

		XPos=MAX_COLUMN-1;

		CurUp();

		}

	}

void SetPos(TInt X, TInt Y)

/**

Set the cursor to a point on the screen

@param X	Character's column

@param Y	Character's row

*/

	{

	XPos=X;

	YPos=Y;

	}

void PutChar(TUint aChar)

/**

Write a character to the screen then moves the cursor to the next position,

scrolling the screen if necessary

@param aChar	Character to write

*/

	{

	switch (aChar)

		{

		case 0x08: CurLeft(); return;		// BS '\b'

		case 0x09: CurRight(); return;		// HT '\t'

		case 0x0a: CurDown(); return;		// LF '\n'

		case 0x0b: CurUp(); return;			// VT '\v'

		case 0x0c: ClearScreen(); return;	// FF '\f'

		case 0x0d: XPos=0; return;			// CR '\r'

		default: break;

		}

	DisplayChar(aChar,XPos,YPos,Colours);

	if (++XPos==MAX_COLUMN)					// chars per line

		{

		XPos=0;

		if (++YPos==(MAX_ROW-3))	// lines per screen - 3 for progress bars & stats

			{

			YPos=(MAX_ROW-4);		// lines per screen - 4

			ScrollScreen();

			}

		}

	}

GLDEF_C void PrintToScreen(TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list,aFmt);

	TBuf<0x100> aBuf;

	aBuf.AppendFormatList(aFmt,list);

	PutString(aBuf);

	//RDebug::RawPrint(aBuf);

	}

void PutString(const TDesC& aBuf)

/**

For each character in the given string write it to the screen

@param aString	String of characters to write

*/

	{

	const TText* pS=aBuf.Ptr();

	const TText* pE=pS+aBuf.Length();

	if (pS!=pE)

		{

		while (pS<pE)

			PutChar(*pS++);

		}

	}

GLDEF_C void InitProgressBar(TInt aId, TUint aLimit, const TDesC& aBuf)

/**

Initialise a progress bar, writes a label and sets the pixels to the

background colour

@param aId		configure Bar0 or Bar1

@param aLimit	Sets the upper bound of the value given to Update

@param aTitle	Label to place before the progress bar (7 characters wide)

*/

	{

	const TText* aTitle=aBuf.Ptr();

	TInt line=aId ? PROGRESSBAR0_ROW : PROGRESSBAR1_ROW;

	Progress[aId]=0;

	if (aId==0)

			StartTime=0;

	Pixels[aId]=0;

	Limit[aId]=aLimit;

	char c;

	TInt x=0;

	while ((c=*aTitle++)!=0 && x<7)

		{

		DisplayChar(c,x,line,Colours);

		++x;

		}

	if (x<7)

		x=7;

	for (; x<(MAX_COLUMN-1); ++x)

		DisplayChar(0x7f,x,line,IPColour[aId]);

	}

GLDEF_C void UpdateProgressBar(TInt aId, TUint aProgress)

/**

Update a progress bar filling in the bar to a new position

If ENABLE_TRANSFER_STATS has been defined at build time the function will

generate some simple statistics.

@param aId			update Bar0 or Bar1

@param aProgress	The point value between 0 and the given aLimit

*/

	{

	TInt line=aId ? PROGRESSBAR0_ROW : PROGRESSBAR1_ROW;

	TUint old_pixels=Pixels[aId];

#ifdef ENABLE_TRANSFER_STATS

	// turn this on and get a few statistics as it loads

	if (aId==0) {

			if (StartTime == 0) {

					StartTime = User::NTickCount();

					ProgressTime[aId] = StartTime;

			}

			TUint avg_bps=0, bps=0, eta=0;

			TUint32 timenow = User::NTickCount();

			TUint32 delta_time = timenow - ProgressTime[aId];

			ProgressTime[aId] = timenow;

			if (delta_time) {

					bps = ((aProgress - Progress[aId]) * 1000) / delta_time;		// delta bytes / delta milliseconds

					delta_time = (timenow - StartTime);					// milliseconds since started

					if (delta_time) {

							avg_bps = ((TUint64)aProgress  * 1000) / delta_time;

							eta = (Limit[aId] - aProgress) / avg_bps;

					}

			}

			TInt savedXPos=XPos, savedYPos=YPos;

			XPos=0;

			YPos=STATS_ROW;

//			Printf("C/s avg: %7d point: %7d ETA: %d    ", avg_bps, bps, eta);

			PrintToScreen(_L("point: %7d ETA: %d    "), bps, eta);

			XPos=savedXPos;

			YPos=savedYPos;

	}

#endif

	Progress[aId]=aProgress;

	Int64 prog64=aProgress;

	prog64*=(Screenwidth - (8*FONT_WIDTH));		// screenwidth in pixels - 8 characters

	prog64/=Limit[aId];

	TUint pixels=(TUint)prog64;

	if (pixels>old_pixels)

		{

		Pixels[aId]=pixels;

		while (old_pixels<pixels)

			{

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

				ColourPixel( old_pixels + (7*FONT_WIDTH), (line * FONT_HEIGHT) + 2 + i  , (PColour[aId]>>8));

			++old_pixels;

			}

		}

	}

void InitDisplay()

/**

Reads the properties of the screen from the HAL and configures the settings so

this driver can colour in pixels.

*/

    {

	TInt iDisplayMode;

	TInt iScreenAddress;

	TInt iBitsPerPixel;

	TInt iIsPalettized;

	TInt offset;

	HAL::Get(HAL::EDisplayMode, iDisplayMode);

	iBitsPerPixel = iDisplayMode; //getbpp needs the current mode as its param

	HAL::Get(HAL::EDisplayBitsPerPixel, iBitsPerPixel);	

	iIsPalettized = iDisplayMode; //ispalettized needs the current mode as its param

	HAL::Get(HAL::EDisplayIsPalettized, iIsPalettized);	

	HAL::Get(HAL::EDisplayMemoryAddress, iScreenAddress);

	offset = iDisplayMode;

	HAL::Get(HAL::EDisplayOffsetToFirstPixel, offset);

	iScreenAddress += offset;

	// get the dimentions of the screen

	HAL::Get(HAL::EDisplayXPixels, Screenwidth);

	HAL::Get(HAL::EDisplayYPixels, Screenheight);

	Screen = (TUint8 *)iScreenAddress;

#if 0

	RDebug::Printf("EDisplayMode %d", iDisplayMode);

	RDebug::Printf("EDisplayBitsPerPixel %d", iBitsPerPixel);

	RDebug::Printf("EDisplayIsPalettized %d", iIsPalettized);

	RDebug::Printf("EDisplayMemoryAddress 0x%x (after offset)", iScreenAddress);

	RDebug::Printf("EDisplayOffsetToFirstPixel  %d",offset);

	RDebug::Printf("EDisplayXPixels  %d",Screenwidth);

	RDebug::Printf("EDisplayYPixels  %d", Screenheight);

#endif

	// get the bits per pixel to work out the size

	if (iBitsPerPixel == 32)

		{

		PixelSize = 4;

		}

	else if (iBitsPerPixel == 16)

		{

		PixelSize = 2;

		}

	else if (iBitsPerPixel == 8)

		{

#if 0

		// derive where the palette is located - assumes when no offset to first

		// pixel the palette is at end of framebuffer.

		TUint8* pV;

		if(vidBuf().iOffsetToFirstPixel)

			pV=(TUint8*)(vidBuf().iVideoAddress);

		else

			pV=(TUint8*)(vidBuf().iVideoAddress)+SCREEN_SIZE;

		// Kern::Printf("Screenbuffer 0x%x palette 0x%x (%dx%d)",Screen,pV,Screenwidth,Screenheight);

		PixelSize = 1;

		memcpy(pV,Palette,32);

#endif

		}

	else

		{

		RDebug::Printf("BOOTLDR display: Unsupported bpp %d",iBitsPerPixel);

		BOOT_FAULT();

		}

	ClearScreen();

	}