CnC_Remastered_Collection

WINDOWS.CPP (37752B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: g:/library/source/rcs/./windows.c 1.12 1994/05/20 15:35:25 joe_bostic Exp $ */
 /***************************************************************************
  **   C O N F I D E N T I A L --- W E S T W O O D   A S S O C I A T E S   **
  ***************************************************************************
  *                                                                         *
  *                 Project Name : LIBRARY                                  *
  *                                                                         *
  *                    File Name : WINDOWS.C                                *
  *                                                                         *
  *                   Programmer : Everyone                                 *
  *                                                                         *
  *                  Last Update : February 3, 1992   [DRD]                 *
  *                                                                         *
  *-------------------------------------------------------------------------*
  * Functions:                                                              *
  *   Change_New_Window -- Combined Change_Window and New_Window.           *
  *   Change_Window -- Changes the 'current' window in the system.          *
  *   Fetch_Char -- Gets one undipthonged char from input.                  *
  *   Flush_Line -- Outputs the accumulate text line to screen.             *
  *   In_Char -- Stores (un-dipped) character(s) from input to buffer.      *
  *   New_Window -- Clears the current window to the background color.      *
  *   Set_More_Off -- Turns the 'more' prompting off.                       *
  *   Set_More_On -- Turns the 'more' prompting on.                         *
  *   Set_More_Prompt -- Adjusts the more prompt text for default routine   *
  *   Standard_More_Prompt -- Default more prompt code for Window_Print     *
  *   Window_Int_Print -- Prints an integer to the window.                  *
  *   Window_Print -- Displays and wraps text into a window.                *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include	<stdio.h>
 #include	<stdarg.h>
 #include <wwstd.h>
 #include "ww_win.h"
 #include <keyboard.h>
 #include	<font.h>
 #include <dipthong.h>
 
 PRIVATE void Scroll_Window(void);
 PRIVATE void Flush_Line(void);
 PRIVATE void In_Char(char *str);
 PRIVATE char Fetch_Char(void);
 
 
 PRIVATE int ScrollCounter = 0;	//	Count of the lines displayed before a pause.
 PRIVATE char Line[84];	// Staging line buffer.
 PRIVATE int Pos;			// Char Position of next free character.
 PRIVATE int PPos;		// Pixel position of next free character.
 PRIVATE int WPos;		// Char position in window.
 PRIVATE char *MainSource;
 PRIVATE char *AltSource;
 PRIVATE char Char[2];
 PRIVATE char Stack;
 PRIVATE char WordWrapFlag = FALSE;	// flag for a word wrap.
 
 PRIVATE int MoreSpace = 7;
 PRIVATE int MoreFColor = 0;
 PRIVATE int MoreBColor = 0;
 
 
 int WindowColumns=40;
 int WindowLines=25;
 int WindowWidth=40;
 unsigned int WinB=0;
 unsigned int WinC=1;
 unsigned int WinX=0;
 unsigned int WinY=0;
 unsigned int WinCx=0;
 unsigned int WinCy=0;
 unsigned int WinH=25;
 unsigned int WinW=40;
 unsigned int Window=0;
 
 int MoreOn = TRUE;
 char *TXT_MoreText = "--More--";
 void (*Window_More_Ptr)(char const *,int,int,int) = Standard_More_Prompt;
 
 extern GraphicViewPortClass *LogicPage;
 /***************************************************************************
  * STANDARD_MORE_PROMPT -- Default more prompt code for Window_Print       *
  *                                                                         *
  *    This is the standard "<more>" prompting code that is used by         *
  *    Window_Print when a page is full of text and a pause is desired      *
  *    before the next page of text is printed.  This function is called    *
  *    through the Window_More_Ptr global.                                  *
  *                                                                         *
  * INPUT:   prompt   -- Pointer to ASCII text that will be window printed  *
  *                      at the right margin.                               *
  *                                                                         *
  *          space    -- The number of spaces to allow for the 'more' text. *
  *                                                                         *
  *          fcolor   -- The foreground color to use for the 'more' text.   *
  *                                                                         *
  *          bcolor   -- The background oclor to use for the 'more' text.   *
  *                                                                         *
  * OUTPUT:     none                                                        *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/29/1991 JLB : Created.                                             *
  *=========================================================================*/
 void Standard_More_Prompt(char const *prompt, int space, int fcolor, int bcolor)
 {
 	int	x, y, moresize;
 
 	moresize = (space - 1) * (FontWidth+FontXSpacing);
 	x = ((WinX+WinW) << 3) - moresize;
 	//y = WinY + ((WinH/FontHeight)-1)*FontHeight;
 	y = WinY + (WinCy-1) * (FontHeight+FontYSpacing);
 
 	// Default "more" prompter.
 	LogicPage->Print(prompt, x, y, fcolor ? fcolor : WindowList[Window][WINDOWBCOL], bcolor ? bcolor : WindowList[Window][WINDOWFCOL]);
 //BG	if (LogicPage == SEENPAGE) {
 //BG		Window_Show_Mouse();
 //BG	}
 
 	// PWG - have to figure out how to do this in windows library
 
 //	Clear_KeyBuffer();
 //	Get_Key();
 
 //BG	if (LogicPage == SEENPAGE) {
 //BG		Window_Hide_Mouse(Window);
 //BG	}
 
 	// Erase the more prompt prompt.
 	//	Text_Print(prompt, x, y, WinB, WinB);
 	LogicPage->Fill_Rect(x, y, x + moresize - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
 }
 
 
 /***************************************************************************
  * SET_MORE_PROMPT -- Adjusts the more prompt text for default routine     *
  *                                                                         *
  *    Use this routine to control the text of the "<MORE>" prompt that     *
  *    the default more prompt routine uses.  This can be useful for        *
  *    foreign language translations.                                       *
  *                                                                         *
  * INPUT:   prompt   -- Pointer to ASCII text that will be window printed  *
  *                      at the right margin.                               *
  *                                                                         *
  *          space    -- The number of spaces to allow for the 'more' text. *
  *                                                                         *
  *          fcolor   -- The foreground color to use for the 'more' text.   *
  *                                                                         *
  *          bcolor   -- The background color to use for the 'more' text.   *
  *                                                                         *
  * OUTPUT:     none                                                        *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/29/1991 JLB : Created.                                             *
  *=========================================================================*/
 void Set_More_Prompt(char const *prompt, int space, int fcolor, int bcolor)
 {
 	if (prompt) {
 		TXT_MoreText = (char*)prompt;
 		MoreSpace = space;
 		MoreFColor = fcolor;
 		MoreBColor = bcolor;
 	}
 	else {
 		TXT_MoreText = "<MORE>";
 		MoreSpace = 7;
 		MoreFColor = MoreBColor = 0;
 	}
 }
 
 
 /***************************************************************************
  * SET_MORE_ON -- Turns the 'more' prompting on.                           *
  *                                                                         *
  *    Use this routine to turn on the 'more' prompting that Window_Print   *
  *    does.  If you have a custom more function pointer, then that         *
  *    routine will be called, otherwise the library default 'more' prompt  *
  *    will be utilized.                                                    *
  *                                                                         *
  * INPUT:      none                                                        *
  *                                                                         *
  * OUTPUT:     none                                                        *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 void Set_More_On(void)
 {
 	MoreOn = TRUE;
 	ScrollCounter = 0;
 }
 
 
 /***************************************************************************
  * SET_MORE_OFF -- Turns the 'more' prompting off.                         *
  *                                                                         *
  *    This routine will turn the 'more' prompting that Window_Print does   *
  *    off.                                                                 *
  *                                                                         *
  * INPUT:   none                                                           *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 void Set_More_Off(void)
 {
 	MoreOn = FALSE;
 }
 
 
 /***************************************************************************
  * CHANGE_WINDOW -- Changes the 'current' window in the system.            *
  *                                                                         *
  *    Use this routine to change the 'current' window.  The current window *
  *    is used in Window_Print and some other graphic output routines.      *
  *                                                                         *
  * INPUT:   windnum  -- The window number to change to.                    *
  *                                                                         *
  * OUTPUT:  Returns with the previously current window.                    *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 int Change_Window(int windnum)
 {
 	int	oldwindow;
 	int	*data;
 
 	oldwindow = Window;
 	Window = windnum;
 	data = &WindowList[windnum][0];
 
 	WinX = *data++;
 	WinY = *data++;
 	WinW = *data++;
 	WinH = *data++;
 	WinC = *data++;
 	WinB = *data++;
 	WinCx = *data++;
 	WinCy = *data++;
 	ScrollCounter = 0;
 	WPos = WinCx / (FontWidth+FontXSpacing);
 	WindowLines = (WinH-FontYSpacing) / (FontHeight+FontYSpacing);
 	WindowWidth = WinW << 3;
 	WindowColumns = WindowWidth / (FontWidth+FontXSpacing);
 	return (oldwindow);
 }
 
 
 /***************************************************************************
  * CHANGE_NEW_WINDOW -- Combined Change_Window and New_Window.             *
  *                                                                         *
  *    This is a combo-routine.  It merely combines the Change_Window       *
  *    with the New_Window routines.  It will save some (small) code if     *
  *    you use this routine instead of the two function calls.              *
  *                                                                         *
  * INPUT:   window   -- Window number to change to and clear.              *
  *                                                                         *
  * OUTPUT:  Returns with the previously current window.                    *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 int Change_New_Window(int windnum)
 {
 	int	oldwindow;
 
 	oldwindow = Change_Window(windnum);
 	New_Window();
 	return(oldwindow);
 }
 
 
 /***************************************************************************
  * NEW_WINDOW -- Clears the current window to the background color.        *
  *                                                                         *
  *    This routine clears the current window to the background color.  It  *
  *    is used in preparation to Window_Print because it ensures a clean    *
  *    'slate' for the text.                                                *
  *                                                                         *
  * INPUT:   none                                                           *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 void New_Window(void)
 {
 	int	x,y,w,h;
 
 	x = WinX << 3;
 	y = WinY;
 	w = (WinX + WinW) << 3;
 	h = WinY + WinH;
 
 	LogicPage->Fill_Rect(x, y, w - 1, h - 1, (unsigned char)WinB);
 
 	WinCx = WPos = 0;
 	WinCy = 0;
 	ScrollCounter = 0;
 }
 
 
 /***************************************************************************
  * WINDOW_INT_PRINT -- Prints an integer to the window.                    *
  *                                                                         *
  *    Use this routine to print an integer to the window.  This routine    *
  *    as all other Window printing routines will handle word wrap.         *
  *                                                                         *
  * INPUT:   num   -- The integer to convert to ASCII and print.            *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 void Window_Int_Print(int num)
 {
 	Window_Print("%d", num);
 }
 
 
 /***************************************************************************
  * WINDOW_PRINT -- Displays and wraps text into a window.                  *
  *                                                                         *
  *    This is the general purpos text output routine that will handle      *
  *    word wrap within a window.  It is useful for displaying arbitrary    *
  *    text.  This routine will handle dipthonged text and as such it       *
  *    can be quite useful in saving memory.                                *
  *                                                                         *
  * INPUT:   string   -- String to print.  This can be of ANY length and    *
  *                      can even contain some formatting codes.  The       *
  *                      codes supported are:                               *
  *                                                                         *
  *             KA_SETX        Forces the cursor X position to the value    *
  *                            specified.                                   *
  *                                                                         *
  *             KA_SETY        Forces the cursor Y position to the value    *
  *                            specified.                                   *
  *                                                                         *
  *             KA_MORE        Causes an immediate "<MORE>" prompt          *
  *                            regardless of the scroll situation.          *
  *                                                                         *
  *             KA_RETURN      Breaks line and continues output at the      *
  *                            left edge of following line.                 *
  *                                                                         *
  *                                                                         *
  *             KA_FORMFEED    Clears the window and continues printing at  *
  *                            the upper left corner.                       *
  *                                                                         *
  *             KA_SETBKGDCOL  Set the background color with the color      *
  *                            specified by the following byte.             *
  *                                                                         *
  *                                                                         *
  *             KA_SETFORECOL  Set the foreground color with the color      *
  *                            specified by the following byte.             *
  *                                                                         *
  *             KA_TAB         Move the cursor over to the next tabstop.    *
  *                            Tabstops are set every 8 columns.            *
  *                                                                         *
  *             KA_SPCTAB      Insert spaces until the cursor is positioned *
  *                            at the next tabstop.                         *
  *                                                                         *
  *             %s             Replace the "%s" with the text pointed to    *
  *                            by the pointer argument passed to the        *
  *                            routine (follows same method a printf).      *
  *                                                                         *
  *             %d             Replace the "%d" with an integer ASCII       *
  *                            number of the int passed to the routine.    *
  *                                                                         *
  * OUTPUT:     none                                                        *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *   07/29/1991 JLB : Added MORE, SETX, and SETY                           *
  *=========================================================================*/
 void Window_Print(char const string[], ...)
 {
 	int		oldcx, x, y;	// Scratch variables.
 	char		c;					// Current character.
 	char		buffer[10];		// Working %d buffer.
 	int		old_c, old_b;	// Original window colors.
 	va_list	arg;				// Argument list var.
 
 
 	va_start(arg, string);
 
 	WordWrapFlag = FALSE;			// initialize word wrap flag.
 	Pos = PPos = 0;
 	Line[0] = '\0';
 	Char[0] = Char[1] = 0;
 	MainSource = (char*)&string[0];
 	AltSource = NULL;
 	old_c = WinC;
 	old_b = WinB;
 
 //BG	if (LogicPage == SEENPAGE) {
 //BG		Window_Hide_Mouse(Window);
 //BG	}
 
 	while (TRUE) {
 
 		c = Fetch_Char();
 
 		if (!c) break;	// Exit on NULL character.
 
 		/*
 		**	Substitution commands only work if not already expanding a
 		**	string.
 		*/
 		if (!AltSource) {
 			if (c == '%') {
 		 		switch(tolower(Char[0])) {
 					case 's':
 						AltSource = va_arg(arg, char*);
 						if (AltSource) {
 							Stack = Char[1];
 							Char[0] = Char[1] = '\0';
 							c = Fetch_Char();
 						}
 						break;
 
 					case 'd':
 						AltSource = buffer;
 						sprintf(buffer, "%d", va_arg(arg, int));
 						Stack = Char[1];
 						Char[0] = Char[1] = '\0';
 						c = Fetch_Char();
 						break;
 
 					default:
 						break;
 				}
 			}
 		}
 
 		switch(c) {
 
 #if(FALSE)
 	// these are the positions of foreign language characters
 			/*
 			** These are characters that shouldn't be window printed because
 			**	they are currently reserved.
 			*/
 			case KA_CTRL_C:
 			case KA_CTRL_D:
 			case KA_CTRL_E:
 			case KA_CTRL_G:
 			case KA_CTRL_J:
 			case KA_CTRL_K:
 			case KA_CTRL_N:
 			case KA_CTRL_O:
 			case KA_CTRL_P:
 			case KA_CTRL_Q:
 			case KA_CTRL_R:
 			case KA_CTRL_T:
 			case KA_CTRL_U:
 			case KA_CTRL_V:
 			case KA_CTRL_W:
 			case KA_CTRL_Z:
 			case KA_CTRL_BACKSLASH:
 			case KA_CTRL_CARROT:
 			case KA_CTRL_UNDERLINE:
 				break;
 #endif
 			/*
 			**	Force cursor column to specified X value.
 			*/
 			case KA_SETX:
 				Flush_Line();
 				WPos  = Fetch_Char();
 				WPos  = MAX(0, WPos);
 
 				// WPos is max width char position
 
 				WPos  = MIN(WindowColumns-1, WPos);
 				WinCx = WPos * (FontWidth+FontXSpacing);
 				break;
 
 			/*
 			**	Force the cursor to specified Y value.
 			*/
 			case KA_SETY:
 				Flush_Line();
 				WinCy = Fetch_Char();
 				//WinCy = MAX(0, WinCy);
 				WinCy = MIN((long)WindowLines-1, (long)WinCy);
 				break;
 
 			/*
 			**	Force a "<MORE>" prompt.
 			*/
 			case KA_MORE:
 				Flush_Line();
 				if (Window_More_Ptr) {
 //BG					if (LogicPage == SEENPAGE) Window_Show_Mouse();
 					Window_More_Ptr(TXT_MoreText, MoreSpace, MoreFColor, MoreBColor);
 //BG					if (LogicPage == SEENPAGE) Window_Hide_Mouse(Window);
 				}
 				break;
 
 			/*
 			**	Clear and home the window cursor.  This is the same
 			**	as New_Window().
 			*/
 			case KA_FORMFEED:
 				New_Window();
 				break;
 
 			/*
 			**	Move cursor to start of next line.
 			*/
 			case KA_RETURN:
 				Flush_Line();
 				ScrollCounter++;
 				WinCx = 0;
 
 #if(FALSE)
 				if (WinCy >= WindowLines-1) {
 					Scroll_Window();
 				}
 				else {
 					WinCy++;
 				}
 #else
 	  			WinCy++;
 #endif
 
 				break;
 
 			/*
 			**	Set the background color.
 			*/
 			case KA_SETBKGDCOL:
 				Flush_Line();
 				WinB = Fetch_Char();
 				break;
 
 			/*
 			**	Set the foreground color.
 			*/
 			case KA_SETFORECOL:
 				Flush_Line();
 				WinC = Fetch_Char();
 				break;
 
 			/*
 			**	Move cursor to next column.
 			*/
 			case KA_TAB:
 				Flush_Line();
 				WPos = ((WPos + 8) & 0xFFF8) - 1;
 				if (WPos >= WindowColumns) {
 					WPos = 0;
 				}
 				WinCx = WPos * (FontWidth+FontXSpacing);
 				break;
 
 			/*
 			**	Tab to specified column but add spaces.
 			*/
 			case KA_SPCTAB:
 				Flush_Line();
 				oldcx = WinCx;
 				x = WinX << 3;
 				y = WinY + (WinCy * (FontHeight+FontYSpacing));
 				WPos = ((WPos + 8) & 0xFFF8) - 1;
 
 				if (WPos >= WindowColumns) {
 					WinCx = WPos = 0;
 
 					// Fill_Rect instead of printing spaces
 
 					LogicPage->Fill_Rect(x + oldcx, y,
 								x + WindowWidth - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
 
 					ScrollCounter++;
 		  			WinCy++;
 				}
 				else {
 					WinCx = WPos * (FontWidth+FontXSpacing);
 
 					// Fill_Rect instead of printing spaces
 
 					LogicPage->Fill_Rect(x + oldcx, y,
 								x + WinCx - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
 				}
 				break;
 
 			/*
 			**	next character is a extended value 1-127, but 128 is added
 			** for a value 129-255
 			*/
 			case KA_EXTEND:
 				c = 127;
 
 			// NOTE: this falls thru to the default case DO NOT MOVE!!!!!
 
 
 			/*
 			**	next character is a literal value 1-127, except 13
 			*/
 //			case KA_LITERAL:
 //				if (c != (char) 127) {	// check if fell thru from extend case
 //					c = 0;					// set to zero for literal case
 //				}
 //				c += Fetch_Char();
 
 			// NOTE: this falls thru to the default case DO NOT MOVE!!!!!
 
 
 			/*
 			**	Normal character output.
 			*/
 			default:
 				PPos += Char_Pixel_Width(c);	// get pixel location of next char
 				Line[Pos++] = c;
 				Line[Pos] = '\0';
 
 				if (WinCx + PPos > (unsigned)WindowWidth) {
 					Flush_Line();
 				}
 				break;
 		}
 	}
 
 	/*
 	**	If there is text still pending, then display it before exiting.
 	*/
 	if (Pos) Flush_Line();
 
 	/*
 	**	Record changes in the cursor position.
 	*/
 	WindowList[Window][WINDOWCURSORX] = WinCx;
 	WindowList[Window][WINDOWCURSORY] = WinCy;
 
 	/*
 	**	Restore the window colors to their original values.
 	*/
 	WindowList[Window][WINDOWFCOL] = WinC = old_c;
 	WindowList[Window][WINDOWBCOL] = WinB = old_b;
 
 //BG	if (LogicPage == SEENPAGE) {
 //BG		Window_Show_Mouse();
 //BG	}
 
 	va_end(arg);
 }
 
 
 /***************************************************************************
  * SCROLL_WINDOW -- Scrolls the text window up one line.                   *
  *                                                                         *
  *    This will scroll the text window up one line.  It will handle any    *
  *    pausing for "more" if the MoreOn flag is set.                        *
  *                                                                         *
  * INPUT:   none                                                           *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   This routine assumes that the LogicPage is the SEENPAGE.    *
  *             If this is not the case, the program may appear to hang     *
  *             if a "more" prompt is generated.                            *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 PRIVATE void Scroll_Window(void)
 {
 	int	y;		// Top pixel row of bottom line of window.
 
 	/*
 	**	Possibly prompt for more text.
 	*/
 	if (ScrollCounter >= WindowLines-1 && MoreOn) {
 		ScrollCounter = 0;
 
 		if (Window_More_Ptr) {
 //BG			if (LogicPage == SEENPAGE) Window_Show_Mouse();
 			Window_More_Ptr(TXT_MoreText, MoreSpace, MoreFColor, MoreBColor);
 //BG			if (LogicPage == SEENPAGE) Window_Hide_Mouse(Window);
 		}
 	}
 
 	/*
 	**	Scroll the window up one line.
 	*/
 	y = ((WinH / (FontHeight+FontYSpacing)) - 1) * (FontHeight+FontYSpacing);
 	LogicPage->Blit(*LogicPage,WinX<<3, WinY + (FontHeight+FontYSpacing), WinX<<3, WinY, WinW<<3, WinH - (FontHeight+FontYSpacing) );
 	LogicPage->Fill_Rect(WinX<<3,
 				WinY + y,
 				((WinX+WinW)<<3) - 1,
 				WinY + WinH - 1,
 				(unsigned char)WinB);
 }
 
 
 /***************************************************************************
  * FLUSH_LINE -- Outputs the accumulate text line to screen.               *
  *                                                                         *
  *    This will display the accumlated text line to the screen.  It will   *
  *    handle breaking the text line at an appropriate position.            *
  *                                                                         *
  * INPUT:   none                                                           *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 PRIVATE void Flush_Line(void)
 {
 	int	breakit, breaksize, breakwidth;
 	int	x, y;					// Coordinates of text print.
 	int	breakpoint;			// Point to break the line (if possible).
 	char	breakchar;			// Break replace character.
 	int	index;				// Backward moving index var.
 
 	/*
 	** There could be a held <CR> and this is implied by the cursor Y position
 	** beyond the bottom of the window.  If this is the case, then scroll the
 	**	window and proceed with the line flush.
 	*/
 	while (WinCy >= (unsigned)WindowLines /*&& Pos > 0*/) {
 		Scroll_Window();
 		if (WinCy >= (unsigned)WindowLines) WinCy--;
 	}
 	//if (WinCy >= WindowLines) WinCy = WindowLines-1;
 
 	x = (WinX<<3) + WinCx;
 	y = WinY + (WinCy*(FontHeight+FontYSpacing));
 
 	breakwidth = WindowWidth;
 //	if (ScrollCounter >= WindowLines - 1 && MoreOn) {
 //		breakwidth -= (MoreSpace * (FontWidth+FontXSpacing));		// use maximum font width
 //	}
 
 	/*
 	**	Try to break the line at the last space IF the line has reached the edge
 	**	of the window.
 	*/
 	breakpoint = Pos;
 	breaksize = PPos;
 	if (WinCx + breaksize > (unsigned)breakwidth) {
 
 		/*
 		**	Since the text WILL spill past the edge of the window, determine the
 		**	point where the break should occur.  If this line is ready for the <MORE>
 		**	prompt, then breaking must account for the <MORE> text.
 		*/
 		if (ScrollCounter >= WindowLines - 1 && MoreOn) {
 			breakwidth -= (MoreSpace * (FontWidth+FontXSpacing));		// use maximum font width
 		}
 		breakwidth -= WinCx;
 
 		breakit = 0;
 		for (index = breakpoint - 1; index > 0; index--) {
 			breakchar = Line[index];
 			breaksize -= Char_Pixel_Width(breakchar);
 
 			// only once, find largest text that can fit on the line
 			if (!breakit) {
 				// was this the char that went past the right edge
 				if (breaksize <= breakwidth) {
 					breakit = index;	// save this position if there is no spaces
 				}
 			}
 
 			// after largest text is found then look for a space to break on
 			if (breakit && breakchar == KA_SPACE) {
 				breakpoint = index;
 				WordWrapFlag = FALSE; // word will start at beginning of next line
 				break;
 			}
 		}
 
 		/*
 		**	Exception: When the current text buffer cannot be broken at a logical
 		**	place AND the text is starting past the left margin, THEN there is
 		**	an implied break between the previous text output and this one.
 		**	Output the current text on the next line left margin.
 		*/
 		if (!index) {
 			if (WinCx && !WordWrapFlag) {
 				breakpoint = breaksize = 0;		// Continue text on next line.
 				WordWrapFlag = TRUE;		// indicate a word continuation.
 			}
 			else {
 				breakpoint = breakit;	// Just print as much as possible.
 			}
 		}
 	}
 
 	breakchar = Line[breakpoint];
 	Line[breakpoint] = '\0';
 
 	LogicPage->Print(Line, x, y, WinC, WinB);
 	WinCx += breaksize;					// add size of text string printed.
 
 	Line[breakpoint] = breakchar;
 	if (breakchar == KA_SPACE) {		// take out a space between words.
 		breakpoint++;
 	}
 
 	// take out another space for double spacing after end of sentence.
 	if (Line[breakpoint] == KA_SPACE) {
 		breakpoint++;
 	}
 
 	strcpy(Line, &Line[breakpoint]);
 	Pos = strlen(Line);
 	PPos = String_Pixel_Width(Line);
 
 	/*
 	**	If at this point there is still text in the buffer, then flushing has
 	**	not been completed.  Scroll to next line and repeat the text flushing
 	**	process.
 	*/
 	if (Pos || WinCx >= (unsigned)WindowWidth) {
 		WinCx = WPos = 0;
 		#if(FALSE)
 			if (WinCy >= WindowLines-1) {
 				Scroll_Window();
 			} else {
 				WinCy++;
 			}
 		#else
 			WinCy++;
 		#endif
 		Flush_Line();
 		ScrollCounter++;	// must be done after flush line for correct counting
 	}
 }
 
 
 /***************************************************************************
  * IN_CHAR -- Stores (un-dipped) character(s) from input to buffer.        *
  *                                                                         *
  *    Use this routine to fetch the next character from the input stream.  *
  *    If the character was dipthonged, then it will be broken into its     *
  *    component ASCII characters and stored in the specified location.     *
  *    This is the core character stream reading code.                      *
  *                                                                         *
  * INPUT:   str   -- char pointer to the position to store the character(s)*
  *                   fetched from the input stream.                        *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 PRIVATE void In_Char(char *str)
 {
 	char	c;		// Character to return.
 	char	next;	// Following character (if any).
 
 	c = next = '\0';
 
 	/*
 	**	Fetch a raw byte from the input stream.
 	*/
 	if (AltSource) {
 		if (*AltSource == '\0') {
 			AltSource = NULL;
 			c = Stack;
 		} else {
 			c = *AltSource++;
 		}
 	}
 
 	if (!c && MainSource) {
 		if (*MainSource == '\0') {
 			MainSource = NULL;
 		} else {
 			c = *MainSource++;
 		}
 	}
 
 	/*
 	**	Convert a dipthong character into it's component
 	**	ASCII characters.
 	*/
 	if (c & 0x80) {
 		c &= 0x7F;
 		next = c & (char)0x07;
 		c = (char)((c & (char)0x78) >> 3);
 
 		next = Dipthong[c][next];	// Dipthong character.
 		c = Common[c];				// Common character.
 	}
 
 	*str++ = c;
 	*str = next;
 }
 
 
 /***************************************************************************
  * FETCH_CHAR -- Gets one undipthonged char from input.                    *
  *                                                                         *
  *    This routine will fetch one character from the input stream.  The    *
  *    character has already been un-dipthonged.  It is a straight ASCII    *
  *    character.  This routine ensures that if the next character in the   *
  *    input stream needs to be examined, it is available in Char[0].       *
  *                                                                         *
  * INPUT:   none                                                           *
  *                                                                         *
  * OUTPUT:  Returns next character in the input stream (ASCII).  If NULL   *
  *          is returned, then this indicates the end of the input stream.  *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   07/25/1991 JLB : Created.                                             *
  *=========================================================================*/
 PRIVATE char Fetch_Char(void)
 {
 	char	c;		// Character to return.
 
 	if (!Char[0]) {
 		In_Char(&Char[0]);
 	}
 
 	c = Char[0];
 	Char[0] = Char[1];
 	Char[1] = '\0';
 
 	if (!Char[0]) {
 		In_Char(&Char[0]);
 	}
 
 	return (c);
 }