CnC_Remastered_Collection

WINSTUB.CPP (32275B)

---

 //
 // 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
 
 
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : WINSTUB.CPP                                                  *
  *                                                                                             *
  *                   Programmer : Steve Tall                                                   *
  *                                                                                             *
  *                   Start Date : 10/04/95                                                     *
  *                                                                                             *
  *                  Last Update : October 4th 1995 [ST]                                        *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Overview:                                                                                   *
  *   This file contains stubs for undefined externals when linked under Watcom for Win 95      *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  *                                                                                             *
  * Functions:                                                                                  *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	"function.h"
 #include "tcpip.h"
 
 void output(short,short)
 {}
 
 bool InDebugger = false;
 bool ReadyToQuit = false;
 
 #if (0)
 /***************************************************************************
  * Extract_Shape_Count -- returns # of shapes in the given shape block		*
  *                                                                         *
  * The # of shapes in a shape block is the first WORD in the block, so		*
  * this is the value returned.															*
  *																									*
  * INPUT:                                                                  *
  * buffer	pointer to shape block, created with MAKESHPS.EXE					*
  *                                                                         *
  * OUTPUT:                                                                 *
  * # shapes in the block																	*
  *                                                                         *
  * WARNINGS:                                                               *
  *	none																							*
  *                                                                         *
  * HISTORY:                                                                *
  *   06/09/1992 JLB : Created.                                             *
  *   08/19/1993 SKB : Split drawshp.asm into several modules.              *
  *   05/25/1994 BR : Converted to 32-bit                                   *
  *=========================================================================*/
 int __cdecl Extract_Shape_Count(VOID const *buffer)
 {
 	ShapeBlock_Type *block = (ShapeBlock_Type *)buffer;
 
 	return (block->NumShapes);
 
 }	/* end of Extract_Shape_Count */
 
 
 /***************************************************************************
  * Extract_Shape -- Gets pointer to shape in given shape block					*
  *                                                                         *
  * INPUT:                                                                  *
  * buffer	pointer to shape block, created with MAKESHPS.EXE					*
  * shape		index of shape to get														*
  *                                                                         *
  * OUTPUT:                                                                 *
  * pointer to shape in the shape block													*
  *                                                                         *
  * WARNINGS:                                                               *
  *	none																							*
  *                                                                         *
  * HISTORY:                                                                *
  *   06/09/1992 JLB : Created.                                             *
  *   08/19/1993 SKB : Split drawshp.asm into several modules.              *
  *   05/25/1994 BR : Converted to 32-bit                                   *
  *=========================================================================*/
 VOID * __cdecl Extract_Shape(VOID const *buffer, int shape)
 {
 	ShapeBlock_Type *block = (ShapeBlock_Type*) buffer;
 	long offset;			// Offset of shape data, from start of block
 	char *bytebuf = (char*) buffer;
 
 	/*
 	----------------------- Return if invalid argument -----------------------
 	*/
 	if (!buffer || shape < 0 || shape >= block->NumShapes)
 		return(NULL);
 
 	offset = block->Offsets[shape];
 
 	return(bytebuf + 2 + offset);
 
 }	/* end of Extract_Shape */
 #endif	//(0)
 
 
 
 unsigned long CCFocusMessage = WM_USER+50;	//Private message for receiving application focus
 extern	void VQA_PauseAudio(void);
 extern	void VQA_ResumeAudio(void);
 
 
 ThemeType OldTheme = THEME_NONE;
 
 
 /***********************************************************************************************
  * Focus_Loss -- this function is called when a library function detects focus loss            *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    Nothing                                                                           *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    2/1/96 2:10PM ST : Created                                                               *
  *=============================================================================================*/
 
 void Focus_Loss(void)
 {
 	if (SoundOn){
 		if (OldTheme == THEME_NONE){
 			OldTheme = Theme.What_Is_Playing();
 		}
 	}
 	Theme.Stop();
 	Stop_Primary_Sound_Buffer();
 	if (WWMouse) WWMouse->Clear_Cursor_Clip();
 }
 
 
 void Focus_Restore(void)
 {
 	Restore_Cached_Icons();
 	Map.Flag_To_Redraw(true);
 	Start_Primary_Sound_Buffer(TRUE);
 	if (WWMouse) WWMouse->Set_Cursor_Clip();
 	VisiblePage.Clear();
 	HiddenPage.Clear();
 }
 
 
 
 /***********************************************************************************************
  * Check_For_Focus_Loss -- check for the end of the focus loss                                 *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    Nothing                                                                           *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    2/2/96 10:49AM ST : Created                                                              *
  *=============================================================================================*/
 
 void Check_For_Focus_Loss(void)
 {
 
 // ST - 1/3/2019 10:40AM	  
 #if (0)
 	static BOOL	focus_last_time = 1;
 			 MSG	msg;
 
 	if ( !GameInFocus ){
 		Focus_Loss();
 		while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE | PM_NOYIELD ) ){
 	  		if( !GetMessage( &msg, NULL, 0, 0 ) ){
 				return;
 			}
 			TranslateMessage(&msg);
 			DispatchMessage(&msg);
 		}
 	}
 
 	if (!focus_last_time && GameInFocus){
 
 		VQA_PauseAudio();
 		CountDownTimerClass cd;
 		cd.Set(60*1);
 
 		do {
 			while (PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE )) {
 	  			if( !GetMessage( &msg, NULL, 0, 0 ) ){
 					return;
 				}
 				TranslateMessage(&msg);
 				DispatchMessage(&msg);
 			}
 
 		} while(cd.Time());
 		VQA_ResumeAudio();
 		//AllSurfaces.Restore_Surfaces();
 		//VisiblePage.Clear();
 		//HiddenPage.Clear();
 		//Map.Flag_To_Redraw(true);
 		PostMessage (MainWindow, CCFocusMessage,0,0);
 	}
 
 	focus_last_time = GameInFocus;
 #endif
 }
 
 
 
 extern BOOL InMovie;
 #if (0) //PG_TO_FIX
 long FAR PASCAL _export Windows_Procedure (HWND hwnd, UINT message, UINT wParam, LONG lParam)
 {
 
 	int	low_param = LOWORD(wParam);
 
 	if (message == CCFocusMessage){
 		Start_Primary_Sound_Buffer(TRUE);
 		if (!InMovie){
 			Theme.Queue_Song(OldTheme);
 			OldTheme = THEME_NONE;
 		}
 		return(0);
 	}
 
 
 	switch ( message ){
 
 		case WM_MOUSEMOVE:
 		case WM_SYSKEYDOWN:
 		case WM_SYSKEYUP:
 		case WM_KEYDOWN:
 		case WM_KEYUP:
 		case WM_LBUTTONDOWN:
 		case WM_LBUTTONUP:
 		case WM_LBUTTONDBLCLK:
 		case WM_MBUTTONDOWN:
 		case WM_MBUTTONUP:
 		case WM_MBUTTONDBLCLK:
 		case WM_RBUTTONDOWN:
 		case WM_RBUTTONUP:
 		case WM_RBUTTONDBLCLK:
 	 		Kbd.Message_Handler(hwnd, message, wParam, lParam);
 			return(0);
 
 		case WM_DESTROY:
 			CCDebugString ("C&C95 - WM_DESTROY message received.\n");
 			CCDebugString ("C&C95 - About to call Prog_End.\n");
 			Prog_End();
 			CCDebugString ("C&C95 - About to Invalidate_Cached_Icons.\n");
 			Invalidate_Cached_Icons();
 			CCDebugString ("C&C95 - About to release the video surfaces.\n");
 			VisiblePage.Un_Init();
 			HiddenPage.Un_Init();
 			AllSurfaces.Release();
 			if (!InDebugger){
 				CCDebugString ("C&C95 - About to reset the video mode.\n");
 				Reset_Video_Mode();
 			}
 			CCDebugString ("C&C95 - About to stop the profiler.\n");
 			Stop_Profiler();
 			CCDebugString ("C&C95 - Posting the quit message.\n");
 			PostQuitMessage( 0 );
 			/*
 			** If we are shutting down gracefully than flag that the message loop has finished.
 			** If this is a forced shutdown (ReadyToQuit == 0) then try and close down everything
 			** before we exit.
 			*/
 			if (ReadyToQuit){
 				CCDebugString ("C&C95 - We are now ready to quit.\n");
 				ReadyToQuit = 2;
 			}else{
 				CCDebugString ("C&C95 - Emergency shutdown.\n");
 				CCDebugString ("C&C95 - Shut down the network stuff.\n");
 #ifndef DEMO
 				Shutdown_Network();
 #endif
 				CCDebugString ("C&C95 - Kill the Winsock stuff.\n");
 				if (Winsock.Get_Connected()) Winsock.Close();
 				CCDebugString ("C&C95 - Call ExitProcess.\n");
 				ExitProcess(0);
 			}
 			CCDebugString ("C&C95 - Clean & ready to quit.\n");
 			return(0);
 
 		case WM_ACTIVATEAPP:
 			GameInFocus=(BOOL)wParam;
 			if (!GameInFocus) {
 				Focus_Loss();
 			}
 			AllSurfaces.Set_Surface_Focus (GameInFocus);
 			AllSurfaces.Restore_Surfaces();
 //			if (GameInFocus){
 //				Restore_Cached_Icons();
 //				Map.Flag_To_Redraw(true);
 //				Start_Primary_Sound_Buffer(TRUE);
 //				if (WWMouse) WWMouse->Set_Cursor_Clip();
 //			}
 			return(0);
 #if (0)
 		case WM_ACTIVATE:
 			if (low_param == WA_INACTIVE){
 				GameInFocus = FALSE;
 				Focus_Loss();
 			}
 			return(0);
 #endif //(0)
 
 		case WM_SYSCOMMAND:
 			switch ( wParam ) {
 
 				case SC_CLOSE:
 					/*
 					** Windows sent us a close message. Probably in response to Alt-F4. Ignore it by
 					** pretending to handle the message and returning 0;
 					*/
 					return (0);
 
 				case SC_SCREENSAVE:
 					/*
 					** Windoze is about to start the screen saver. If we just return without passing
 					** this message to DefWindowProc then the screen saver will not be allowed to start.
 					*/
 					return (0);
 			}
 			break;
 
 #ifdef FORCE_WINSOCK
 		case WM_ACCEPT:
 		case WM_HOSTBYADDRESS:
 		case WM_HOSTBYNAME:
 		case WM_ASYNCEVENT:
 		case WM_UDPASYNCEVENT:
 	 		Winsock.Message_Handler(hwnd, message, wParam, lParam);
 			return (0);
 #endif	//FORCE_WINSOCK
 	}
 
 	return (DefWindowProc (hwnd, message, wParam, lParam));
 }
 
 #endif
 
 
 
 
 
 
 
 
 /***********************************************************************************************
  * Create_Main_Window -- opens the MainWindow for C&C                                          *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    instance -- handle to program instance                                            *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    10/10/95 4:08PM ST : Created                                                             *
  *=============================================================================================*/
 
 #define CC_ICON 1
 int ShowCommand;
 
 void Create_Main_Window ( HANDLE instance ,int command_show , int width , int height )
 
 {
 	MainWindow = NULL;
 	return;
 #if (0)
 	HWND        	hwnd ;
 	WNDCLASS    	wndclass ;
 	//
 	// Register the window class
 	//
 
 	wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
 	wndclass.lpfnWndProc   = Windows_Procedure ;
 	wndclass.cbClsExtra    = 0 ;
 	wndclass.cbWndExtra    = 0 ;
 	wndclass.hInstance     = instance ;
 	wndclass.hIcon         = LoadIcon (instance, MAKEINTRESOURCE(CC_ICON)) ;
 	wndclass.hCursor       = NULL;
 	wndclass.hbrBackground = NULL;
 	wndclass.lpszMenuName  = "Command & Conquer";	//NULL
 	wndclass.lpszClassName = "Command & Conquer";
 
 	RegisterClass (&wndclass) ;
 
 
 	//
 	// Create our main window
 	//
 	hwnd = CreateWindowEx (
 							WS_EX_TOPMOST,
 							"Command & Conquer",
 							"Command & Conquer",
 							WS_POPUP | WS_MAXIMIZE,
 							0,
 							0,
 							width,
 							height,
 							NULL,
 							NULL,
 							instance,
 							NULL );
 
 	ShowWindow (hwnd, command_show );
 	ShowCommand = command_show;
 	UpdateWindow (hwnd);
 	SetFocus (hwnd);
 	MainWindow=hwnd;			//Save the handle to our main window
 	hInstance = instance;
 
 	CCFocusMessage = RegisterWindowMessage ("CC_GOT_FOCUS");
 
 	Audio_Focus_Loss_Function = &Focus_Loss;
 	Misc_Focus_Loss_Function = &Focus_Loss;
 	Misc_Focus_Restore_Function = &Focus_Restore;
 	Gbuffer_Focus_Loss_Function = &Focus_Loss;
 #endif
 }
 
 void Window_Dialog_Box(HANDLE  hinst, LPCTSTR  lpszTemplate, HWND  hwndOwner, DLGPROC  dlgprc)
 {
 #if (0)
 	MSG					msg;
 	/*
 	** Get rid of the Westwood mouse cursor because we are showing a
 	** dialog box and we want to have the right windows cursor showing
 	** for it.
 	*/
 	Hide_Mouse();
 	ShowCursor(TRUE);
 
 	/*
 	** Pop up the dialog box and then run a standard message handler
 	** until the dialog box is closed.
 	*/
 
 	DialogBox(hinst, lpszTemplate, hwndOwner, dlgprc);
 	while (GetMessage(&msg, NULL, 0, 0) && !AllDone) {
 		TranslateMessage(&msg);
 		DispatchMessage(&msg);
 	}
 
 	/*
 	** Restore the westwood mouse cursor and get rid of the windows one
 	** because it is now time to restore back to the westwood way of
 	** doing things.
 	*/
 	ShowCursor(FALSE);
 	Show_Mouse();
 #endif
 }
 
 
 
 typedef struct tColourList {
 
 	char	Red;
 	char	Green;
 	char	Blue;
 } ColourList;
 
 ColourList	ColourLookup[9]={
 	0,0,0,
 	63,0,0,
 	0,63,0,
 	0,0,63,
 	63,0,63,
 	63,63,0,
 	0,63,63,
 	32,32,32,
 	63,63,63
 };
 
 
 
 
 int	DebugColour=1;
 
 
 extern "C" void Set_Palette_Register(int number,int red ,int green ,int blue);
 //#pragma off (unreferenced)
 void Colour_Debug (int call_number)
 {
 	//#if 0
 	//if (DebugColour==call_number || !call_number){
 
 		//if (call_number){
 		//	Wait_Vert_Blank();
 		//}
 
 		// ST - 1/3/2019 10:43AM
 		//Set_Palette_Register (0,ColourLookup[call_number].Red ,
 		//								ColourLookup[call_number].Green,
 		//								ColourLookup[call_number].Blue);
 	//}
 	//#endif
 }
 
 //#pragma on (unreferenced)
 
 
 
 
 
 BOOL Any_Locked (void)
 {
 	if (SeenBuff.Get_LockCount() ||
 		HidPage.Get_LockCount()){
 		return (TRUE);
 	}else{
 		return(FALSE);
 	}
 }
 
 
 
 
 
 
 
 HANDLE DebugFile = INVALID_HANDLE_VALUE;
 
 /***********************************************************************************************
  * CCDebugString -- sends a string to the debugger and echos it to disk                        *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    string                                                                            *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    10/28/96 12:48PM ST : Created                                                            *
  *=============================================================================================*/
 void CCDebugString (char *string)
 {
 #if (0)
 
 	char outstr[256];
 
 	sprintf (outstr, "%s", string);
 
 	DWORD	actual;
 	if (DebugFile == INVALID_HANDLE_VALUE){
 		DebugFile = CreateFile("debug.txt", GENERIC_WRITE, 0,
 												NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 	}else{
 		DebugFile = CreateFile("debug.txt", GENERIC_WRITE, 0,
 												NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 	}
 
 	if (DebugFile != INVALID_HANDLE_VALUE){
 		SetFilePointer (DebugFile, 0, NULL, FILE_END);
 		WriteFile(DebugFile, outstr, strlen(outstr)+1, &actual, NULL);
 		CloseHandle (DebugFile);
 	}
 
 	OutputDebugString (string);
 
 #else
 
 	string = string;
 
 #endif
 
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 //
 // Miscellaneous stubs. Mainly for multi player stuff
 //
 //
 //
 
 //IPXAddressClass::IPXAddressClass(void) {
 //	int i;
 //	i++;
 //}
 //int IPXManagerClass::Num_Connections(void){ return (0); }
 //int IPXManagerClass::Connection_ID( int ) { return (0); }
 //IPXAddressClass * IPXManagerClass::Connection_Address( int ) { return ((IPXAddressClass*)0); }
 //char * IPXManagerClass::Connection_Name( int ) { return ((char*)0); }
 //int IPXAddressClass::Is_Broadcast() { return (0); }
 //int IPXManagerClass::Send_Global_Message( void *, int, int, IPXAddressClass * ) { return (0); }
 //int IPXManagerClass::Service() { return (0); }
 //int IPXManagerClass::Get_Global_Message( void  *, int  *, IPXAddressClass  *, short unsigned  * ) { return (0); }
 //int IPXAddressClass::operator ==( IPXAddressClass  & ) { return (0); }
 //IPXManagerClass::IPXManagerClass( int, int, int, int, short unsigned, short unsigned ) {}
 //IPXManagerClass::~IPXManagerClass() {
 //	int i;
 //	i++;
 //	}
 //int  IPXManagerClass::Delete_Connection( int ) { return (0); }
 //IPXAddressClass::IPXAddressClass( char unsigned  *, char unsigned  * ){}
 //void  IPXManagerClass::Set_Socket( short unsigned ){}
 //int  IPXManagerClass::Is_IPX() { return (0); }
 //int  IPXManagerClass::Init() { return (0); }
 //void  IPXAddressClass::Get_Address( char unsigned  *, char unsigned  * ){}
 //void  IPXManagerClass::Set_Bridge( char unsigned  * ){}
 //int  IPXManagerClass::Global_Num_Send() { return (0); }
 //void  IPXManagerClass::Set_Timing( long unsigned, long unsigned, long unsigned ){}
 //unsigned long IPXManagerClass::Global_Response_Time() { return (0); }
 //int  IPXManagerClass::Create_Connection( int, char  *, IPXAddressClass  * ) { return (0); }
 //int  IPXAddressClass::operator !=( IPXAddressClass  & ) { return (0); }
 //int  IPXManagerClass::Send_Private_Message( void  *, int, int, int ) { return (0); }
 //int  IPXManagerClass::Get_Private_Message( void  *, int  *, int  * ) { return (0); }
 //int  IPXManagerClass::Connection_Index( int ) { return (0); }
 //void  IPXManagerClass::Reset_Response_Time(){}
 //long unsigned  IPXManagerClass::Response_Time() { return (0); }
 //int  IPXManagerClass::Private_Num_Send( int ) { return (0); }
 
 //_VQAHandle  *  VQA_Alloc(void){ return ((_VQAHandle *)0); }
 //void  VQA_Init( _VQAHandle  *, long ( *)()) {}
 //long  VQA_Open( _VQAHandle  *, char const  *, _VQAConfig  * ) { return (0); }
 //void  VQA_Free( _VQAHandle  * ) {}
 //void  VQA_Close( _VQAHandle  * ) {}
 //long  VQA_Play( _VQAHandle  *, long ) { return (0); }
 
 //void VQA_Init(VQAHandle *, long(*)(VQAHandle *vqa, long action,	void *buffer, long nbytes)){}
 
 //long VQA_Open(VQAHandle *, char const *, VQAConfig *)
 //{
 //	return (0);
 //}
 
 //void VQA_Close(VQAHandle *){}
 
 //long VQA_Play(VQAHandle *, long)
 //{
 //	return (0);
 //}
 
 
 unsigned char	*VQPalette;
 long				VQNumBytes;
 unsigned long	VQSlowpal;
 bool				VQPaletteChange = false;
 
 
 extern "C"{
 	void __cdecl SetPalette(unsigned char *palette,long numbytes,unsigned long slowpal);
 }
 
 
 
 void Flag_To_Set_Palette(unsigned char *palette,long numbytes,unsigned long slowpal)
 {
 	VQPalette = palette;
 	VQNumBytes = numbytes;
 	VQSlowpal = slowpal;
 	VQPaletteChange = true;
 }
 
 
 
 void Check_VQ_Palette_Set(void)
 {
 	if (VQPaletteChange){
 		SetPalette(VQPalette, VQNumBytes, VQSlowpal);
 		VQPaletteChange = false;
 	}
 }
 
 
 
 
 
 void __cdecl SetPalette(unsigned char *palette,long,unsigned long)
 {
 	for (int i=0 ; i<256*3 ; i++){
 		*(palette+i)&=63;
 	}
 	Increase_Palette_Luminance(palette , 15 , 15 , 15 ,63);
 
 	if (PalettesRead){
 		memcpy (&PaletteInterpolationTable[0][0] , InterpolatedPalettes[PaletteCounter++] , 65536);
 	}
 	Set_Palette(palette);
 }
 
 
 
 /***********************************************************************************************
  * Memory_Error_Handler -- Handle a possibly fatal failure to allocate memory                  *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    Nothing                                                                           *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    5/22/96 3:57PM ST : Created                                                              *
  *=============================================================================================*/
 void Memory_Error_Handler(void)
 {
 	GlyphX_Debug_Print("Error - out of memory.");
 	VisiblePage.Clear();
 	Set_Palette(GamePalette);
 	while (Get_Mouse_State()){Show_Mouse();};
 	CCMessageBox().Process("Error - out of memory.", "Abort", false);
 	Invalidate_Cached_Icons();
 	
 	// Nope. ST - 1/10/2019 10:38AM
 	//PostQuitMessage( 0 );
 	//ExitProcess(0);
 }
 
 
 
 
 
 
 
 
 
 
 
 GraphicBufferClass* Read_PCX_File(char* name, char* Palette, void *Buff, long Size);
 
 
 
 /***********************************************************************************************
  * Load_Title_Screen -- loads the title screen into the given video buffer                     *
  *                                                                                             *
  *                                                                                             *
  *                                                                                             *
  * INPUT:    screen name                                                                       *
  *           video buffer                                                                      *
  *           ptr to buffer for palette                                                         *
  *                                                                                             *
  * OUTPUT:   Nothing                                                                           *
  *                                                                                             *
  * WARNINGS: None                                                                              *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *    7/5/96 11:30AM ST : Created                                                              *
  *=============================================================================================*/
 
 void Load_Title_Screen(char *name, GraphicViewPortClass *video_page, unsigned char *palette)
 {
 
 	GraphicBufferClass *load_buffer;
 
 
 	load_buffer = Read_PCX_File (name, (char*)palette, NULL, 0);
 
 	if (load_buffer){
 		load_buffer->Blit(*video_page);
 		delete load_buffer;
 	}
 }
 
 
 
 #include "filepcx.h"
 
 /***************************************************************************
  * READ_PCX_FILE -- read a pcx file into a Graphic Buffer                  *
  *                                                                         *
  *	GraphicBufferClass* Read_PCX_File (char* name, char* palette ,void *Buff, long size );	*
  *  																								*
  *                                                                         *
  * INPUT: name is a NULL terminated string of the fromat [xxxx.pcx]        *
  *        palette is optional, if palette != NULL the the color palette of *
  *					 the pcx file will be place in the memory block pointed	   *
  *               by palette.																*
  *			 Buff is optinal, if Buff == NULL a new memory Buffer		 			*
  *					 will be allocated, otherwise the file will be placed 		*
  *					 at location pointd by Buffer;										*
  *			Size is the size in bytes of the memory block pointed by Buff		*
  *				  is also optional;
  *                                                                         *
  * OUTPUT: on succes a pointer to a GraphicBufferClass cointaining the     *
  *         pcx file, NULL othewise.                                        *
  *																									*
  * WARNINGS:                                                               *
  *         Appears to be a comment-free zone                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   05/03/1995 JRJ : Created.                                             *
  *   04/30/1996 ST : Tidied up and modified to use CCFileClass             *
  *=========================================================================*/
 
 #define	POOL_SIZE 2048
 #define	READ_CHAR()  *file_ptr++ ; \
 							 if ( file_ptr	>= & pool [ POOL_SIZE ]	) { \
 								 file_handle.Read (pool , POOL_SIZE ); \
 								 file_ptr = pool ; \
 							 }
 
 /*
 ** The old RGB was signed, so the shift right didn't work. ST - 1/4/2019 4:49PM
 */
 typedef	struct {
 	unsigned char	red ;
 	unsigned char	green ;
 	unsigned char	blue ;
 } PG_RGB ;
 
 GraphicBufferClass* Read_PCX_File(char* name, char* palette, void *Buff, long Size)
 {
 	int					i, j;
 	unsigned					rle;
 	unsigned					color;
 	int					scan_pos;
 	unsigned char			*file_ptr;
 	int						width;
 	int						height;
 	unsigned char						*buffer;
 	PCX_HEADER				header;
 	PG_RGB					*pal;
 	unsigned char						pool [POOL_SIZE];
 	GraphicBufferClass	*pic;
 
 	CCFileClass file_handle(name);
 
 	if (!file_handle.Is_Available()) return (NULL);
 
 	file_handle.Open(READ);
 
 	file_handle.Read (&header, sizeof (PCX_HEADER));
 
 	if (header.id != 10 &&  header.version != 5 && header.pixelsize != 8 ) return NULL ;
 
 	width = header.width - header.x + 1;
 	height = header.height - header.y + 1;
 
 	if (Buff) {
     	buffer = (unsigned char*) Buff;
     	i = Size / width;
     	height = MIN (i - 1, height);
     	pic = new GraphicBufferClass(width, height, buffer, Size);
     	if ( !(pic && pic->Get_Buffer()) ) return NULL ;
 	} else {
     	pic = new GraphicBufferClass(width, height, NULL, width*(height+4));
     	if ( !(pic && pic->Get_Buffer()) ) return NULL ;
 	}
 
 	buffer = (unsigned char *) pic->Get_Buffer();
 	file_ptr = pool ;
 	file_handle.Read (pool , POOL_SIZE);
 
 	if ( header.byte_per_line != width ){
 
 		for ( scan_pos = j = 0 ; j < height ; j ++, scan_pos += width ) {
 			for ( i = 0 ; i < width ; ) {
 				rle = READ_CHAR ();
 				if ( rle > 192 ) {
 					rle -= 192 ;
 					color =	READ_CHAR (); ;
 					memset ( buffer + scan_pos + i , color , rle );
 					i += rle;
 				} else {
 					*(buffer+scan_pos + i++ ) = (char)rle;
 				}
 			}
       	}
 
 		if ( i == width ) rle = READ_CHAR ();
 		if ( rle > 192 )  rle = READ_CHAR ();
 
 	} else {
 
 		for ( i = 0 ; i < width * height ; ) {
   			rle = READ_CHAR ();
   			rle &= 0xff;
   			if ( rle > 192 ) {
         		rle -= 192 ;
         		color = READ_CHAR ();
   				memset ( buffer + i , color , rle );
         		i += rle ;
       		}else{
 				*(buffer + i++) = rle;
 			}
 		}
 	}
 
 	if ( palette ) {
 		file_handle.Seek (- (256 * (int)sizeof ( PG_RGB )) , SEEK_END );
 		file_handle.Read (palette , 256L * sizeof ( PG_RGB ));
 
 		pal = ( PG_RGB * ) palette;
 		for (i = 0 ; i < 256 ; i ++) {
 			pal ->red	>>= 2;
 			pal ->green	>>= 2;
 			pal ->blue	>>= 2;
 			pal ++ ;
 		}
 	}
 
 	file_handle.Close();
 	return pic;
 }