plc_display.lib

//$Id: ism_display.lib,v 1.2 2008-07-27 00:48:10 charlie Exp $

/*

   $Log: ism_display.lib,v $

*/

/*** BeginHeader */

#ifndef __ISM_DISPLAY_

#define __ISM_DISPLAY_

/*** EndHeader */

/*** BeginHeader

	InitializeDisplay,

	DisplayText,

	DisplayTextCentered,

	DisplayWindowText,

	DisplayTextAt,

	DisplayTextCenteredAt,

	DisplayWindowTextAt,

	DisplayMsg,

	DisplayMsg1,

	DisplayMsg2,

	DisplayMsg1Ctr,

	DisplayMsg2Ctr,

	DisplayMsgCtr,

	DisplayMsg1Pair,

	DisplayMsg2Pair,

	DisplayBrightness,

	DisplayDefineWindow,

	DisplayReverse,

	DspMsgArrow,

	Display2Stdio,

	DisplayToggleQuiet,

	DisplayMagnify,

	ConcatMsg,

   DisplayInit4711,

	DspUpdate4711,

	WrtCmd,

	WrtData

*/

// ASCII Constants

#define ESC 0x1b

#define US 0x1f

#define CLR 0x0c

#define HOM 0x0b

#define HT 0x09

#define BS 0x08

// Hardware Constants

#define DSP_MD1 0x01            // See hardware documentation

#define DSP_MD2 0x02

#define DSP_MD3 0x03

#define PBUSY_BIT 0x80          // Busy status bit from the hardware

// Port definitions

#if BOARDREV == 'A'

	#define DISPLAY_WR_PORT PEDR    // The write bit is in the E port

	#define DISPLAY_WR_BIT 0        // The wirte bit is bit 0

#endif

#if BOARDREV == 'B'

	#define DISPLAY_WR_PORT PEDR    // The write bit is in the E port

	#define DISPLAY_WR_BIT 5        // The wirte bit is bit 5

	#define DISPLAY_RD_PORT PEDR    // The read bit is in the E port

	#define DISPLAY_RD_BIT 5        // The read bit is bit 5

#endif

#if BOARDREV == 'C'

	#define DISPLAY_WR_PORT PEDR    // The write bit is in the E port

	#define DISPLAY_WR_BIT 7        // The wirte bit is bit 7

	#define DISPLAY_RD_PORT PEDR    // The read bit is in the E port

	#define DISPLAY_RD_BIT 7        // The read bit is bit 7

#endif

   #define DISPLAY_ADR_BIT_CMD ((~2) & (0xf))       // The address bit to 0

   #define DISPLAY_ADR_BIT_DTA ((~0) & (0xf))       // The address bit to 1

// Other Constants

#define TIMEOUT_MS 100L /* Must be long */

#define DEFAULT_BRIGHTNESS 8

/*****************************************************************

	API for AUTOPAK_DISPLAY.LIB

*****************************************************************/

typedef enum

{

	STDIO_OFF,

	STDIO_ON

} 	StdioMode; // An enumerated type to indicate stdio on or off

// API Function Prototypes

/***********************************************************

	void InitializeDisplay(StdioMode mode)

		Call at initialization time to get the display ready

		for use.

		InitializeDisplay takes the initial StdioMode as its argument

		Returns nothing

***********************************************************/

nodebug void InitializeDisplay(StdioMode mode);

/*******************************************************************

	int DisplayText(char *text)

		Clear the display and display the given text

		at cursor position 0,0

		Returns 0

	int DisplayTextCentered(char *text)

		Same as DisplayText, but centers the text

********************************************************************/

nodebug int DisplayText(char *text);

nodebug int DisplayTextCentered(char *text);

/********************************************************************

	int DisplayWindowText(char window, char *text)

		Clear the given window, and write the given text in

		the given window.

		Returns 0

********************************************************************/

nodebug int DisplayWindowText(char window, char *text);

/********************************************************************

	int DisplayTextAt(char *text, char x, char y)

		Set the cursor to x,y, and display the given text.

		x and y refer to character positions, not pixel positions.

		Returns 0

	int DisplayTextCenteredAt(char *text, char x, char y)

		Same as DisplayTextAt, but centers the text

********************************************************************/

nodebug int DisplayTextAt(char *text, char x, char y);

nodebug int DisplayTextCenteredAt(char *text, char x, char y);

/********************************************************************

	int DisplayWindowTextAt(char window, char *text, char x, char y)

		Select the given window, set the cursor to x,y in the window,

		and display the given text.

		x and y refer to character positions, not pixel positions.

		Returns 0

********************************************************************/

nodebug int DisplayWindowTextAt(char window, char *text, char x, char y);

/********************************************************************

	int DisplayMsg(char *line1, char *line2)

		Display the given text in window 0: line1 on line 1 and line2 on line 2

	Returns 0

	int DisplayMsgCtr(char *line1, char *line2)

	Same as DisplayMsg, but centers the text on each line

********************************************************************/

nodebug int DisplayMsg(char *line1, char *line2);

nodebug int DisplayMsgCtr(char *line1, char *line2);

/********************************************************************

	int DisplayMsg1(char *line)

		Display the given text in window 0, line 1

	int DisplayMsg2(char *line)

		Display the given text in window 0, line 2

	Returns 0

	int DisplayMsg1Ctr(char *line)

	int DisplayMsg2Ctr(char *line)

	Same as DisplayMsg1 and DisplayMsg2, but centers the text

********************************************************************/

nodebug int DisplayMsg1(char *line);

nodebug int DisplayMsg2(char *line);

nodebug int DisplayMsg1Ctr(char *line);

nodebug int DisplayMsg2Ctr(char *line);

/********************************************************************

	int DisplayMsg1Pair(int leftPad, char *leftMsg, char *rightMsg, int rightPad)

		Display the given text on line 1.

		  leftMsg is left-justified after leaving leftPad blanks on the left side

		  rightMsg is right-justified after leaving rightPad blanks on the right side

	Returns 0

********************************************************************/

nodebug int DisplayMsg1Pair(int leftPad, char *leftMsg, char *rightMsg, int rightPad);

nodebug int DisplayMsg2Pair(int leftPad, char *leftMsg, char *rightMsg, int rightPad);

/********************************************************************

	int DisplayBrightness(char n)

		Set the brightness from 1 to 8.

		Returns 0

********************************************************************/

nodebug int DisplayBrightness(char n);

/*******************************************************************

	DisplayDefineWindow(char n, int xpos, int ypos, int xsize, int ysize)

		Define a window. xpos, ypos, xsize and ysize are the location

		of the upper-left corner of the window, and the size of

		the window, all in pixels.

		Returns 0

********************************************************************/

nodebug int DisplayDefineWindow(char n, int xpos, int ypos, int xsize, int ysize);

/*******************************************************************

	DisplayReverse(int mode)

		Control the "reverse" mode: 1 => reverse mode, 0=> normal mode.

		The reverse mode applies to all subsequent characters written

		to the currently active window. Reverse mode is reset to

		"normal" when the window is cleared.

		Returns 0

*******************************************************************/

nodebug int DisplayReverse(int mode);

/******************************************************************

	int DisplayClear(void)

		Cear the entire display.

		Returns 0

******************************************************************/

nodebug int DisplayClear(void);

/******************************************************************

	int DisplayWindowClear(int window)

		Clear a window, designated by the argument.

		Returns 0

******************************************************************/

nodebug int DisplayWindowClear(int window);

/******************************************************************

	void DspMsgArrow(char *line1, char *line2);

		Show a two-line message, and append an arrow to the end

		of the second line.

*******************************************************************/

nodebug void DspMsgArrow(char *line1, char *line2);

/******************************************************************

	void Display2Stdio(StdioMode mode);

		Turn on/off echoing of display messages to stdio

	void DisplayToggleQuiet()

	   Toggles echoing of display messages to stdio

*******************************************************************/

nodebug void Display2Stdio(StdioMode mode);

nodebug void DisplayToggleQuiet();

/******************************************************************

	void DisplayMagnify(int n)

		Change the size of subsequently written characters

	n = 1 -> normal size

	n = 2 -> double size

	Returns 0

******************************************************************/

nodebug int DisplayMagnify(int n);                // Magnify subsequenty written characters: 1 => normal, 2 => 2x

/******************************************************************

	char *ConcatMsg(char *msg1, char *msg2, char *resultMsg)

		Concatonate msg1 and msg2, storing the result in resultMsg.

		The total resultant string is no longer than DISPLAY_LENGTH

******************************************************************/

nodebug char *ConcatMsg(char *msg1, char *msg2, char *resultMsg); // Concatonate two messages. Total result is no longer than DISPLAY_LENGTH

void	DisplayInit4711 ();								//initialize display								//write initial revision msg to display

int	DspUpdate4711 (char *aLine1, char *aLine2);						//write array to display

int	WrtCmd (char aChar);						//write specified command code to display 4711

int	WrtData (char aChar);					//write display table contents to display 4711

/*****************************************************************

	End of API for AUTOPAK_DISPLAY.LIB

*****************************************************************/

/*** EndHeader */

// Local Function Prototypes

nodebug int DisplayWrChar(char);                  // Write a byte to the display module

nodebug int DisplayWrString(char*);               // Write a string to the display module

nodebug int DisplaySelectWindow(char window); 		// Select the "current window", 0 - 4, where 0 is the Main window

nodebug int DisplayCharacterWidth(int w);         // Set the character cell width: 0 => 6 dots, 1 => 7 dots

nodebug int DisplaySetCursor(int x, int y); 		// Set the cursor position (the character position)

nodebug char *centerText(char *text, int leftEdge);

nodebug char *centerText2(char *text, int leftEdge);

nodebug int displayMsgPair(int leftPad, char *leftMsg, char *rightMsg, int rightPad, int lineNo);

nodebug int WrChar(char aChar);

nodebug int WrString(char *aString);

// Variables

int CharacterWidth;     // Character width in dots

int CharacterHeight;    // Character height in dots

int Magnification;      // 1 => 1x magnification, 2 => 2x magnification

StdioMode display2StdioFlag;  // Echo all display strings to stdio?

// API functions

void InitializeDisplay(StdioMode mode)

{

	int value;

	printf("Init Display ...\n");

	Display2Stdio(mode);

	CharacterHeight = 8;

	Disp.Timer 			= MS_TIMER;

	Disp.HoldTimer		= MS_TIMER;

	Disp.NextUpdate	= DSP_HOLD;

	Disp.UpdateFlag	= 1;

	Disp.Chan			= -1;

	Disp.Hold			= 0;

// Set up the hardware write bit

#if BOARDREV == 'A'

	value = THREE_WAIT | WRITE_STROBE | PERMIT_WRITE;

	WrPortI(IbRegister(DISPLAY_WR_BIT), NULL, value); // Set the appropriate I/O Bank Control register

	BitWrPortI(PEFR, &PEFRShadow, 1, DISPLAY_WR_BIT);

	BitWrPortI(PEDDR, &PEDDRShadow, 1, DISPLAY_WR_BIT);

#endif

// Set up the hardware read / write bit

#if BOARDREV == 'B' || BOARDREV == 'C'

	value = THREE_WAIT | CHIP_SELECT | PERMIT_WRITE;

	WrPortI(IbRegister(DISPLAY_WR_BIT), NULL, value); // Set the appropriate I/O Bank Control register

	BitWrPortI(PEFR, &PEFRShadow, 1, DISPLAY_WR_BIT);

	BitWrPortI(PEDDR, &PEDDRShadow, 1, DISPLAY_WR_BIT);

 //	value = THREE_WAIT | READ_STROBE;

 //	WrPortI(IbRegister(DISPLAY_RD_BIT), NULL, value);  // Set the appropriate I/O Bank Control register

 //	BitWrPortI(PEFR, &PEFRShadow, 1, DISPLAY_RD_BIT);

 //	BitWrPortI(PEDDR, &PEDDRShadow, 1, DISPLAY_RD_BIT);

#endif

#if BOARDREV == 'C'

	DisplayInit4711();

#else

	// Initialize

	   WrChar(ESC);

	   WrChar('@');

	// Clear

	   DisplayClear();

	// Overwrite Mode (DSP_MD1)

	   WrChar(US);

	   WrChar(DSP_MD1);

	// Set the default brightness

	   DisplayBrightness(DEFAULT_BRIGHTNESS);

	// Fixed character width 1

	   DisplayCharacterWidth(1);

	// No Magnification

	   DisplayMagnify(1);

	// Display screen mode = 0

	   WrChar(US);

	   WrChar('(');

	   WrChar('w');

	   WrChar(0x10);

	   WrChar(0);

	// American Font Set

	   WrChar(ESC);

	   WrChar('R');

	   WrChar(0);

	// USA Character Code Type

	   WrChar(ESC);

	   WrChar('t');

	   WrChar(0);

	// Non-reverse mode

	   DisplayReverse(0);

	// Write Mixture = Normal

	   WrChar(US);

	   WrChar('w');

	   WrChar(0);

	// Normal size

	   DisplayMagnify(1);

#endif

}

int DisplayText(char *text) {return DisplayWindowText(0, text);}

char centeredText[DISPLAY_LENGTH + 1];

char centeredText2[DISPLAY_LENGTH + 1];

int DisplayTextCentered(char *text)

{

	DisplayText(centerText(text, 0));

}

char *centerText(char *text, int leftEdge)

{

	int i;

	int tspaces;

	tspaces = 0;

	tspaces = DISPLAY_LENGTH - leftEdge - strlen(text);

	if (tspaces < 0)

	{

		tspaces = 0;

		leftEdge = 0;

	}

	memset(centeredText, 0, sizeof(centeredText));

	for (i = 0 ; i < leftEdge + tspaces / 2 ; i++)

	{

		centeredText[i] = ' ';

	}

	strcat(centeredText + i, text);

	return centeredText;

}

char *centerText2(char *text, int leftEdge)

{

	int i;

	int tspaces;

	tspaces = 0;

	tspaces = DISPLAY_LENGTH - leftEdge - strlen(text);

	if (tspaces < 0)

	{

		tspaces = 0;

		leftEdge = 0;

	}

	memset(centeredText2, 0, sizeof(centeredText2));

	for (i = 0 ; i < leftEdge + tspaces / 2 ; i++)

	{

		centeredText2[i] = ' ';

	}

	strcat(centeredText2 + i, text);

	return centeredText2;

}

int DisplayWindowTextCentered(char window, char *text)

{

	DisplayWindowText(window, centerText(text, 0));

}

int DisplayWindowText(char window, char *text)

{

	int result;

	int i;

	result = 0;

	// Select the window

	DisplaySelectWindow(window);

	// Clear the window

	DisplayWindowClear(window);

	// Write the text

	WrString(text);

	return result;

}

int DisplayTextAt(char *text, char xpos, char ypos)

{

	return DisplayWindowTextAt(0, text, xpos, ypos);

}

int DisplayTextCenteredAt(char *text, char xpos, char ypos)

{

	return DisplayWindowTextAt(0, centerText(text, xpos), xpos, ypos);

}

int DisplayMsg(char *line1, char *line2)

{

	int result;

	result = 0;

#if BOARDREV == 'C'

	result = DspUpdate4711(line1, line2);

#else

	result |= DisplayText(line1);

	result |= DisplayTextAt(line2, 0, 1);

#endif

	return result;

}

int DisplayMsg1(char *line)

{

	DisplayText(line);

	return 0;

}

int DisplayMsg2(char *line)

{

	DisplayTextAt(line, 0, 1);

	return 0;

}

int DisplayMsg1Ctr(char *line)

{

	DisplayTextCentered(line);

}

int DisplayMsg2Ctr(char *line)

{

	DisplayTextCenteredAt(line, 0, 1);

}

int DisplayMsgCtr(char *line1, char *line2)

{

	int result;

   result = 0;

#if BOARDREV == 'C'

	result = DspUpdate4711(centerText(line1, 0), centerText2(line2, 0));

#else

	result |= DisplayTextCentered(line1);

	result |= DisplayTextCenteredAt(line2, 0, 1);

#endif

	return result;

}

int DisplayMsg1Pair(int leftPad, char *leftMsg, char *rightMsg, int rightPad)

{

	return displayMsgPair(leftPad, leftMsg, rightMsg, rightPad, 0);

}

int DisplayMsg2Pair(int leftPad, char *leftMsg, char *rightMsg, int rightPad)

{

	return displayMsgPair(leftPad, leftMsg, rightMsg, rightPad, 1);

}

int displayMsgPair(int leftPad, char *leftMsg, char *rightMsg, int rightPad, int lineNo)

{

	char msg[DISPLAY_LENGTH+1];

	char aSpace;

	int i;

	char *ptr;

	int innerPad;

	innerPad = DISPLAY_LENGTH - leftPad - strlen(leftMsg) - strlen(rightMsg) - rightPad;

	if (innerPad < 0) innerPad = 0; // This'll look ugly, but it's the best we can do given the inputs

	aSpace = ' ';

	memset(msg, 0, sizeof(msg));

	ptr = msg;

	for (i = 0 ; i < leftPad && ptr - msg <= DISPLAY_LENGTH ; i++)

	{

		*ptr++ = aSpace;

	}

	if (ptr - msg + strlen(leftMsg) <= DISPLAY_LENGTH)

	{

		strcat(msg, leftMsg);

		ptr += strlen(leftMsg);

	}

	for (i = 0 ; i < innerPad && ptr - msg <= DISPLAY_LENGTH ; i++)

	{

		*ptr++ = aSpace;

	}

	if (ptr - msg + strlen(rightMsg) <= DISPLAY_LENGTH)

	{

		strcat(msg, rightMsg);

		ptr += strlen(rightMsg);

	}

	for (i = 0 ; i < rightPad && ptr - msg <= DISPLAY_LENGTH ; i++)

	{

		*ptr++ = aSpace;

	}

	DisplayTextAt(msg, 0, lineNo);

	return 0;

}

int DisplayWindowTextAt(char window, char *text, char xpos, char ypos)

{

	int result;

	int i;

	result = 0;

// Select the window

	DisplaySelectWindow(window);

// Position the cursor

	DisplaySetCursor(xpos, ypos);

// Write the text

	WrString(text);

	return result;

}

int DisplayBrightness(char n)

{

	int result;

	WrChar(US);

	WrChar('X');

	WrChar(n);

	result = 0;

	return result;

}

int DisplaySelectWindow(char a)

{

	int result;

	result = 0;

	WrChar(US);

	WrChar('(');

	WrChar('w');

	WrChar(1);

	WrChar(a);

	return result;

}

int DisplayDefineWindow(char window, int xpos, int ypos, int xsize, int ysize)

{

	int result;

	char xPL, xPH, yPL, yPH, xSL, xSH, ySL, ySH;

	result = 0;

	xPL = xpos & 0xff;

	xPH = (xpos & 0xff00) >> 8;

	yPL = ypos & 0xff;

	yPH = (ypos & 0xff00) >> 8;

	xSL = xsize & 0xff;

	xSH = (xsize & 0xff00) >> 8;

	ySL = ysize & 0xff;

	ySH = (ysize & 0xff00) >> 8;

	WrChar(US);

	WrChar('(');

	WrChar('w');

	WrChar(2);

	WrChar(window);

	WrChar(1);

	WrChar(xPL);

	WrChar(xPH);

	WrChar(yPL);

	WrChar(yPH);

	WrChar(xSL);

	WrChar(xSH);

	WrChar(ySL);

	WrChar(ySH);

	return result;

}

int DisplayReverse(int mode)

{

	WrChar(US);

	WrChar('r');

	WrChar(mode);

}

void DspMsgArrow(char *line1, char *line2)

{

	DisplayText(line1);

	DisplayTextAt(line2, 0, 1);

	DisplayTextAt(">", 15, 1);

}

// Local functions

int WrChar(char aChar)

{

	int result;

	int i;

	Ms then;

	int rdDisplayAddress;

	result = 0;

	then = (Ms)MS_TIMER;

#if BOARDREV == 'A'

	while (MS_TIMER - then < 3l);

  WrPortE(ExternalAddress(DISPLAY_WR_BIT), NULL, aChar);

#endif

#if BOARDREV == 'B'

	rdDisplayAddress = ExternalAddress(DISPLAY_RD_BIT) + 0x000f;

	while ((RdPortE(rdDisplayAddress) & PBUSY_BIT) &&

	         (MS_TIMER - then < TIMEOUT_MS));

	WrPortE(ExternalAddress(DISPLAY_WR_BIT), NULL, aChar);

#endif

#if BOARDREV == 'C'

	result = WrtData(aChar);

#endif

	return result;

}

int WrString(char *aString)

{

	int result;

	int i;

	result = 0;

	for (i = 0 ; i < strlen(aString) ; i++) WrChar(aString[i]);

	if (display2StdioFlag == STDIO_ON) printf("Display::WrString: %s\n", aString);

	return result;

}

int DisplayClear()

{

	return DisplayWindowClear(0);

}

int DisplayWindowClear(int window)

{

	int result;

	result = 0;

	DisplaySelectWindow(window);

	WrChar(CLR);

	return result;

}

int DisplayCharacterWidth(int w)

{

	int result;

	result = 0;

	WrChar(US);

	WrChar('(');

	WrChar('g');

	WrChar(3);

	WrChar(w);

	CharacterWidth = 0;

	if (w == 0) CharacterWidth = 6;

	if (w == 1) CharacterWidth = 7;

	return result;

}

int DisplayMagnify(int n)

{

	if (n > 2) n = 2;

	if (n < 1) n = 1;

	WrChar(US);

	WrChar('(');

	WrChar('g');

	WrChar(0x40);

	WrChar(n);

	WrChar(n);

	Magnification = n;

}

int DisplaySetCursor(int xpos, int ypos)

{

	char xL, xH, yL, yH;

	xpos *= CharacterWidth * Magnification;

	ypos *= Magnification;

	xL = xpos & 0xff;

	xH = (xpos & 0xff00) >> 8;

	yL = ypos & 0xff;

	yH = (ypos & 0xff00) >> 8;

	WrChar(US);

	WrChar('$');

	WrChar(xL);

	WrChar(xH);

	WrChar(yL);

	WrChar(yH);

}

void Display2Stdio(StdioMode mode)

{

	display2StdioFlag = mode;

}

void DisplayToggleQuiet() // needs to be root because it is called indirectly from keyboard.lib

{

	display2StdioFlag = (display2StdioFlag == STDIO_ON) ? STDIO_OFF : STDIO_ON;

}

char concatMsg[DISPLAY_LENGTH + 1];

char *ConcatMsg(char *msg1, char *msg2, char *resultMsg)

{

	char *dest;

	dest = concatMsg;

	if (resultMsg != NULL) dest = resultMsg;

	StrSafeCopy(dest, msg1, DISPLAY_LENGTH);

	strncat(dest, msg2, DISPLAY_LENGTH - strlen(dest));

	return dest;

}

//Write specified command code to display 4711  ******************************************

int	WrtCmd (char aChar)

{

	int result;

	result = 0;

	WrPortE(ExternalAddress(DISPLAY_WR_BIT) + DISPLAY_ADR_BIT_CMD, NULL, aChar);												//return form asm code subroutine

   return result;

}

//Write chareter in display table array to display - 4711 ********************************

int	WrtData (char aChar)

{

	int result;

	result = 0;

	WrPortE(ExternalAddress(DISPLAY_WR_BIT) + DISPLAY_ADR_BIT_DTA, NULL, aChar);												//return form asm code subroutine

	return result;

}

//Display initialization ****************************************************************

void	DisplayInit4711 ()

{

	WrtCmd (0x38);										//function set, initialize to 8 bit mode

	MsDelay (5);										//delay 5 ms

	WrtCmd (0x38);										//function set, initialize to 8 bit mode

	MsDelay (5);										//delay 5 ms

	WrtCmd (0x08);										//turn display off

	MsDelay (5);										//delay 5 ms

	WrtCmd (0x01);										//clear display to blanks

	MsDelay (5);										//delay 5 ms

	WrtCmd (0x0C);										//set display on, cursor off, blink off

	MsDelay (5);										//delay 5 ms

	WrtCmd (0x06);										//set increment ads, cursor shift on

	MsDelay (5);

}

//Display Update from selected array ****************************************************

int	DspUpdate4711 (char *aLine1, char *aLine2)

{

	int i;												//declare local variable

   int result;

   result = 0;

	MsDelay (5);										//delay in case dsp wrts are close

	WrtCmd (0x80);										//set DDRAM to begin of first half

	MsDelay (5);

   for (i = 0 ; i < strlen(aLine1) ; i++)

   {

   	WrtData(aLine1[i]);										//delay for dsp exec

		MsDelay (2);									//delay for dsp exec

	}

	WrtCmd (0xC0);										//set DDRAM to begin of second half

	MsDelay (5);										//delay for dsp exec

   for (i = 0 ; i < strlen(aLine2) ; i++)

   {

   	WrtData(aLine2[i]);										//delay for dsp exec

		MsDelay (2);									//delay for dsp exec

	}

}

/*** BeginHeader */

#endif

/*** EndHeader */