// 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();

 	}