autorun.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program 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.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/****************************************************************************
 ** 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 : Autorun                                  *
 *                                                                          *
 *                     File Name : AUTORUN.CPP                              *
 *                                                                          *
 *                    Programmers: Maria del Mar McCready Legg              *
 *                                                                          *
 *                    Start Date : September 5, 1997                        *
 *                                                                          *
 *                   Last Update : October 15, 2001  [MML]                  *
 *                                                                          *
 *--------------------------------------------------------------------------*
 * Functions:                                                               *
 *      WinMain                                                             *
 *      Main::MessageLoop                                                   *
 *      MainWindow::Register                                                *
 *      MainWindow::MainWindow                                              *
 *      MainWindow::Window_Proc                                             *
 *      MainWindow::Is_Product_Registered                                   *
 *      MainWindow::Run_Explorer                                            *
 *      MainWindow::Run_Game                                                *
 *      MainWindow::Run_Setup                                               *
 *      MainWindow::Run_New_Account                                         *
 *      MainWindow::Run_Register                                            *
 *      MainWindow::Run_Auto_Update                                         *
 *      MainWindow::Run_Uninstall                                           *
 *      MainWindow::Create_Buttons                                          *
 *      Wnd_Proc                                                            *
 *      Dialog_Box_Proc                                                     *
 *      Stop_Sound_Playing                                                  *
 *      Options                                                             *
 *      Valid_Environment                                                   *
 *      LoadResourceBitmap                                                  *
 *      CreateDIBPalette                                                    *
 *      LoadResourceButton                                                  *
 *      Cant_Find_MessageBox                                                *
 *      Error_Message                                                       *
 *      Path_Add_Back_Slash                                                 *
 *      Path_Remove_Back_Slash                                              *
 *      PlugInProductName                                                   *
 *      Fix_Single_Ampersands                                               *
 *      Fix_Double_Ampersands                                               *
 *      LaunchObjectClass::LaunchObjectClass                                *
 *      LaunchObjectClass::SetPath                                          *
 *      LaunchObjectClass::SetArgs                                          *
 *      LaunchObjectClass::Launch                                           *
 *--------------------------------------------------------------------------*/
 
 
#define  STRICT
#include <windows.h>
#include <windowsx.h>
#include <assert.h>
#include <ctype.h>
#include <direct.h>
#include <dos.h>
#include <errno.h>
#include <fcntl.h>
#include <fstream.h>
#include <io.h>
#include <locale.h>
#include <math.h>
#include <mbctype.h>
#include <mmsystem.h>
#include <process.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <strstrea.h>
#include <sys\stat.h>
#include <time.h>
#include <winuser.h>
#include "args.h"
#include "autorun.h"
#include "drawbutton.h"
#include "resource.h"
#include "wnd_file.h" 
//#include "visualc.h"
#include "winfix.h"
#include "cdcntrl.h"
#include "igr.h"
#include "viewhtml.h"
 
#include "utils.h"
#include "locale_api.h"
//#include "resources.h"
#include "getcd.h"
 
#include "WSYS_FileSystem.h"
#include "WSYS_STDFileSystem.h"
 
#include <string>
#include "GameText.h"
 
#include "leanAndMeanAutorun.h"
 
#ifndef LEAN_AND_MEAN
#include "Common/SubsystemInterface.h"
#include "GameClient/GameText.h"
#include "Common/UnicodeString.h"
#include "Win32Device/Common/Win32LocalFileSystem.h"
#include "Win32Device/Common/Win32BIGFileSystem.h"
#endif
 
 
 
//-----------------------------------------------------------------------------
//  DEFINES
//-----------------------------------------------------------------------------
#define     PRETEND_ON_CD_TEST              FALSE       // should be FALSE
//#define   PRETEND_ON_CD_TEST              TRUE        // should be FALSE
 
#define     WINDOW_BRUSH                    FALSE
#define     BACKGROUND_BITMAP               TRUE
#define     USE_MOUSE_MOVES                 TRUE
#define     DISABLE_KEYBOARD                FALSE
 
#define     BUTTON_WIDTH                    150
#define     BUTTON_HEIGHT                   45
#define     NUM_BUTTONS                     10
#define     NUM_ARGUMENTS                   10
#define     NUM_SONGS                       2       //32 //16
#define     NUM_FLICKER_FRAMES              1
#define     NUM_FLICKER_POSITIONS           15
 
#define     MOUSE_WAV                       "MouseMove"  
#define     SOUND_FILE1                     "SPEECH_FILE1"
#define     SOUND_FILE2                     "SPEECH_FILE2"
 
#define     MOH_DEMO_PROGRAM                "MOHAADEMO\\SETUP.EXE"
#define     SHOW_MOH_DEMO                   FALSE
 
#define     BFAVI_FILENAME                  "Autorun\\BF1942RTR.avi"
#define     SC4AVI_FILENAME                 "Autorun\\Preview.avi"
#define     HELP_FILENAME                   "HELP:FILENAME"//"Support\\eahelp.hlp"
 
#define     SHOW_GAMESPY_BUTTON             FALSE
#define     GAMESPY_WEBSITE                 "http://www.gamespyarcade.com/features/launch.asp?svcname=ccrenegade&distID=391"
 
#define     RESOURCE_FILE                   "Autorun.loc"
#define     SETUP_INI_FILE1                 "Setup\\Setup.ini"
#define     SETUP_INI_FILE2                 "Setup.ini"
 
#define     UNINSTALL_EXECUTABLE            "IDriver.exe"           // JFS
 
//-----------------------------------------------------------------------------
// These defines need the Product name from Setup.ini to complete.
//-----------------------------------------------------------------------------
#define     SETUP_MAIN_WINDOW_NAME          "%s Setup" 
#define     CLASS_NAME                      "%s Autorun" 
#define     GAME_MAIN_WINDOW_NAME           "%s Game Window" 
 
//#define   GAME_WEBSITE                    "http://www.westwood.com/" 
#define     GAME_WEBSITE                    "http://generals.ea.com" 
 
#define     AUTORUN_MUTEX_OBJECT            "01AF9993-3492-11d3-8F6F-0060089C05B1" 
//#define       GAME_MUTEX_OBJECT           "C6D925A3-7A9B-4ca3-866D-8B4D506C3665" 
#define     GAME_MUTEX_OBJECT               "685EAFF2-3216-4265-B047-251C5F4B82F3"
#define     PRODUCT_VOLUME_CD1              "Generals1"
#define     PRODUCT_VOLUME_CD2              "Generals2"
 
 
//-----------------------------------------------------------------------------
// Global Variables
//-----------------------------------------------------------------------------
LaunchObjectClass  LaunchObject;
MainWindow            *GlobalMainWindow   = NULL;
int                 Language            = 0;
int                 LanguageToUse      = 0;
 
DrawButton *ButtonList          [ NUM_BUTTONS ];
RECT        ButtonSizes          [ NUM_BUTTONS ];
char        ButtonImages        [ NUM_BUTTONS ][ MAX_PATH ];
CHAR        szSongPath            [ MAX_PATH ];
char        FocusedButtonImages  [ NUM_BUTTONS ][ MAX_PATH ];
char        Arguments          [ NUM_ARGUMENTS ][ 30 ];
char        szWavs                [ NUM_SONGS][ _MAX_PATH ];
char        szBuffer            [ MAX_PATH ];
char        szBuffer1          [ MAX_PATH ];
char        szBuffer2          [ MAX_PATH ];
char        szBuffer3          [ MAX_PATH * 2];
char        szInternetPath        [_MAX_PATH];
char        szGamePath            [_MAX_PATH];
char        szWorldbuilderPath    [_MAX_PATH];
char        szPatchgetPath    [_MAX_PATH];
char        szSetupPath          [_MAX_PATH];
char        szUninstallPath      [_MAX_PATH];
char        szUninstallCommandLine[_MAX_PATH];        // JFS: Returned value contains parameters needed.
char        szRegisterPath        [_MAX_PATH];
char        szButtonWav          [_MAX_PATH ];
char        szSpeechWav          [_MAX_PATH ];
char        szArgvPath            [_MAX_PATH ];
char        drive              [_MAX_DRIVE];
char        dir                  [_MAX_DIR  ];
char        szSetupWindow      [_MAX_PATH];
char        szGameWindow        [_MAX_PATH];
char        szRegistryKey      [_MAX_PATH];
char        szClassName          [_MAX_PATH];
char        szVolumeName        [_MAX_PATH];
 
char        szProduct_Name        [ _MAX_PATH ];
 
 
#ifdef LEAN_AND_MEAN
 
wchar_t     szWideBuffer        [ _MAX_PATH ];
wchar_t     szWideBuffer0          [ _MAX_PATH ];
wchar_t     szWideBuffer2          [ _MAX_PATH ];
wchar_t     szWideBuffer3          [ _MAX_PATH ];
wchar_t     szProductName        [ _MAX_PATH ];
wchar_t     szFullProductName  [ _MAX_PATH ];
 
/*
enum
{   
    IDS_INSTALL,
    IDS_EXPLORE_CD,
    IDS_PREVIEWS,
    IDS_CANCEL,
    IDS_AUTORUN_TITLE,
    IDS_CANT_FIND_IEXPLORER,
    IDS_WINDOWS_VERSION_TEXT,
    IDS_WINDOWS_VERSION_TITLE,
    IDS_CANT_FIND,
    IDS_UNINSTALL,
    IDS_WEBSITE,
    IDS_CHECKFORUPDATES,
    IDS_WORLDBUILDER,
    IDS_PLAY,
 
    IDS_GAME_TITLE,
    IDS_FULL_GAME_TITLE,
    IDS_REGISTRY_KEY,
    IDS_MAIN_WINDOW,
 
 
    IDS_COUNT // keep this last
};
*/
 
#else
 
UnicodeString wideBuffer;
UnicodeString wideBuffer0;
UnicodeString wideBuffer2;
UnicodeString wideBuffer3;
UnicodeString  productName;
UnicodeString fullProductName;
 
#endif
 
 
 
bool        IsEnglish              = FALSE;
bool        UseSounds              = FALSE;
bool        b640X480                = FALSE;
bool        b800X600                = FALSE;
BOOL        OnCDRom              = FALSE;
BOOL        IAmWindows95            = FALSE;
BOOL        InstallProduct            = TRUE;
BOOL        UninstallAvailable        = FALSE;
BOOL        IsUserRegistered        = FALSE;
BOOL        DisplayRegisterButton  = FALSE;
BOOL        IsWolapiAvailable      = FALSE;
BOOL        CDLocked                = FALSE;
int         WindowsVersion            = 0;
int         NumberArguments          = 0;
int         SongNumber                = 0;
HANDLE      AppMutex                = NULL;
HANDLE      GameAppMutex            = NULL;
HANDLE      SetupAppMutex          = NULL;
 
 
 
 
#ifdef LEAN_AND_MEAN
 
extern FileSystem *TheFileSystem;
 
#else
 
extern GameTextInterface *TheGameText;
extern LocalFileSystem *TheLocalFileSystem;
extern ArchiveFileSystem *TheArchiveFileSystem;
 
#endif
 
// stuff needed to compile.
HWND        ApplicationHWnd = NULL;
HINSTANCE ApplicationHInstance;             
 
const char *g_strFile = "Autorun.str";
const char *g_csfFile = "Autorun.csf";
 
char *gAppPrefix = "ar_"; // prefix to the debug log.
 
int         FlickerPositions[ NUM_FLICKER_POSITIONS ][2];
 
#if( _DEBUG )
char        szCDDrive[ MAX_PATH ];
#endif
 
 
//-----------------------------------------------------------------------------
// Global Function Definitions
//-----------------------------------------------------------------------------
void        Cant_Find_MessageBox        ( HINSTANCE hInstance, char *szPath );
HPALETTE    CreateDIBPalette            ( LPBITMAPINFO lpbmi, LPINT lpiNumColors );
void        Debug_Date_And_Time_Stamp  ( void );
 
void        Error_Message              ( HINSTANCE hInstance, int title, int string, char *path );
void        Error_Message              ( HINSTANCE hInstance, const char * title, const char * string, char *path );
 
bool        Is_On_CD                    ( char * );
HBITMAP     LoadResourceBitmap            ( HMODULE hInstance, char *lpString, HPALETTE FAR *lphPalette, bool loading_a_button=FALSE );
HBITMAP     LoadResourceButton            ( HMODULE hInstance, char *lpString, HPALETTE FAR lphPalette );
BOOL        Options                      ( Command_Line_Arguments *Orgs );
void        Prog_End                    ( void );
bool        Prompt_For_CD              ( HWND window_handle, char *volume_name, const char * message1, const char * message2, int *cd_drive );
void        Reformat_Volume_Name        ( char *volume_name, char *new_volume_name );
int         Show_Message                ( HWND window_handle, const char * message_num1, const char * message_num2 );
int         Show_Message                ( HWND window_handle, int message_num1 );
void        Stop_Sound_Playing            ( void );
BOOL        Valid_Environment          ( void );
 
BOOL        CALLBACK    Dialog_Box_Proc  ( HWND window_handle, UINT message, WPARAM w_param, LPARAM l_param );
LRESULT     CALLBACK    Wnd_Proc        ( HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam );
 
 
//-----------------------------------------------------------------------------
// Main & MainWindow Public Variables
//-----------------------------------------------------------------------------
HINSTANCE   Main::hInstance  = 0;
HINSTANCE   Main::hPrevInstance  = 0;
HMODULE     Main::hModule      = 0;
int         Main::nCmdShow        = 0;
char        MainWindow::szClassName[] = CLASS_NAME;
 
 
//*****************************************************************************
// WinMain --   Main Program Loop.
//
// INPUT:       HINSTANCE hInstance
//                  HINSTANCE hPrevInstance
//                  LPTSTR lpszCmdLine
//                  int nCmdShow
//
// OUTPUT:      int.
//
// WARNINGS:    none.
//
// HISTORY:
//   06/04/1996 MML : Created.
//=============================================================================
 
int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpszCmdLine, int nCmdShow )
{
 
    int     i = 0;
    char    szPath[ _MAX_PATH ];
    char    szIniPath[ _MAX_PATH ];
 
    HANDLE              handle;
    WIN32_FIND_DATA     FindFileData;
 
    Main::hInstance      = hInstance;
    ApplicationHInstance = hInstance;
    Main::hPrevInstance  = hPrevInstance;
    Main::nCmdShow        = nCmdShow;
    Main::hModule      = GetModuleHandle( NULL );
 
    memset( szSetupWindow,     '\0', MAX_PATH );
    memset( szGameWindow,       '\0', MAX_PATH );
    memset( szProductName,     '\0', MAX_PATH );
    memset( szFullProductName, '\0', MAX_PATH );
    memset( szRegistryKey,     '\0', MAX_PATH );
    memset( szClassName,     '\0', MAX_PATH );
    memset( szVolumeName,       '\0', MAX_PATH );
 
    Msg( __LINE__, __FILE__, "Entering WinMain." );
 
    //-------------------------------------------------------------------------
    // Set Cleanup function.
    //-------------------------------------------------------------------------
    atexit( Prog_End );
 
    //-------------------------------------------------------------------------
    // Clear Argument Array.
    //-------------------------------------------------------------------------
    for ( i = 0; i < NUM_ARGUMENTS; i++ ) {
        memset( Arguments[i], '\0', sizeof( Arguments[i] ));
    }
    for ( i = 0; i < NUM_SONGS; i++ ) {
        memset( szWavs[i], '\0', sizeof( szWavs[i] ));
    }
 
    //-------------------------------------------------------------------------
    // Init Args class.
    //-------------------------------------------------------------------------
    Args = new Command_Line_Arguments( hInstance, GetCommandLine());
    if ( Args == NULL ) {
//      Error_Message( hInstance, IDS_ERROR, IDS_COMMAND_LINE_ERR, NULL );
        Error_Message( hInstance, "Autorun:Error", "Autorun:CommandLineError", NULL );
        return( 0 );
    }
    Msg( __LINE__, __FILE__, "Args Created." );
 
#if( PRETEND_ON_CD_TEST )
    strcpy( szCDDrive, "E:\\" );
    Options( Args );
    strcat( szCDDrive, "autorun.exe" );
    Msg( __LINE__, __FILE__, "szCDDrive = %s.", szCDDrive );
    Args->Set_argv( 0, szCDDrive );
#endif
 
    //-------------------------------------------------------------------------
    // Get the CD volume to check on which CD in the product we are on.
    //-------------------------------------------------------------------------
    strcpy( szBuffer, Args->Get_argv(0));
    CDList.Get_Volume_For_This_CD_Drive( szBuffer, szVolumeName );
 
    Msg( __LINE__, __FILE__, "szVolumeName  = %s.", szVolumeName );
 
 
#ifdef LEAN_AND_MEAN
 
    TheFileSystem = new StdFileSystem;
 
#else
 
    // create singletons
    TheFileSystem->init();
    TheLocalFileSystem = new Win32LocalFileSystem;
    TheArchiveFileSystem = new Win32BIGFileSystem;
    TheGameText = CreateGameTextInterface();
    TheGameText->init();
 
#endif
 
    //=========================================================================
    // Make paths to .INI and .LOC files.
    //=========================================================================
    Make_Current_Path_To( RESOURCE_FILE, szPath );
    Make_Current_Path_To( SETUP_INI_FILE1, szIniPath );
 
    handle = FindFirstFile( szIniPath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
 
        //---------------------------------------------------------------------
        // This might be a secondary CD.
        //---------------------------------------------------------------------
        Make_Current_Path_To( SETUP_INI_FILE2, szIniPath );
    }
    FindClose( handle );    
 
    Msg( __LINE__, __FILE__, "Resource file = %s.", szPath );
    Msg( __LINE__, __FILE__, "Setup.ini file = %s.", szIniPath );
 
    //--------------------------------------------------------------------------
    // Get the language we are using from the Setup.ini file.
    //--------------------------------------------------------------------------
    Language = GetPrivateProfileInt( "Setup", "Language", 0, szIniPath );
 
    if( Language == 0 ) {
        IsEnglish = true;
    }
 
    Msg( __LINE__, __FILE__, "Language = %d.", Language );
    Msg( __LINE__, __FILE__, "IsEnglish = %d.", IsEnglish );
 
    //--------------------------------------------------------------------------
    // Set language to use.  
    //--------------------------------------------------------------------------
    if( Locale_Use_Multi_Language_Files()) {
 
        if( IS_LANGUAGE_DBCS( Language ) && !IS_CODEPAGE_DBCS( CodePage )) {
            Language = LANG_USA;
        }
 
        /*switch( Language ) {
 
            case LANG_GER:
                LanguageToUse = IDL_GERMAN;
                break;
 
            case LANG_FRE:
                LanguageToUse = IDL_FRENCH;
                break;
 
            case LANG_JAP:
                LanguageToUse = IDL_JAPANESE;
                break;
 
            case LANG_KOR:
                LanguageToUse = IDL_KOREAN;
                break;
 
            case LANG_CHI:
                LanguageToUse = IDL_CHINESE;
                break;
 
            case LANG_USA:
            default:
                LanguageToUse = IDL_ENGLISH;
                break;
        }
        */
        LanguageToUse = Language;
 
    }
    Msg( __LINE__, __FILE__, "LanguageToUse = %d.", LanguageToUse );
 
    //-------------------------------------------------------------------------
    // Process the Command Line Options.  This may change the language id.
    //-------------------------------------------------------------------------
    if ( !Options( Args )) {
        return( 0 );
    }
 
    //-------------------------------------------------------------------------
    // Save off the Current path for use by other stuff.
    //-------------------------------------------------------------------------
    _tcscpy( szArgvPath, Args->Get_argv(0));
    _tsplitpath( szArgvPath, drive, dir, NULL, NULL );
    _tmakepath ( szArgvPath, drive, dir, NULL, NULL );
    Path_Add_Back_Slash( szArgvPath );
    Msg( __LINE__, TEXT(__FILE__), TEXT("szArgvPath = %s."), szArgvPath );
 
    Msg( __LINE__, __FILE__, "About to Init text strings." );
 
    //=========================================================================
    // Init the strings chosen.
    //=========================================================================
 
 
    Locale_Init( LanguageToUse, szPath );
 
    /*
    if( !Locale_Init( LanguageToUse, szPath )) {
        LoadString( Main::hInstance, IDS_CANT_FIND_FILE, szBuffer1, _MAX_PATH );
        MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szPath, _MAX_PATH, szWideBuffer0, _MAX_PATH );
        sprintf( szBuffer2, szBuffer1, szWideBuffer0 );
        MessageBox( NULL, szBuffer2, "Autorun", MB_APPLMODAL | MB_OK );
        return 0;
    }
    */
 
 
    //-------------------------------------------------------------------------
    // Get some pertinent strings.
    //-------------------------------------------------------------------------
    Locale_GetString( "Autorun:Title",      szProductName );
    Locale_GetString( "Autorun:Command&ConquerGenerals",        szFullProductName );
    //Locale_GetString( IDS_GAME_TITLE, szProductName );
    //Locale_GetString( IDS_FULL_GAME_TITLE,    szFullProductName );
//  Locale_GetString( IDS_REGISTRY_KEY,     szRegistryKey );            // jfs
//  Locale_GetString( IDS_MAIN_WINDOW,      szGameWindow );
 
 
    //-------------------------------------------------------------------------
    // Set other variables used through out.
    //-------------------------------------------------------------------------
#ifdef LEAN_AND_MEAN
 
    //Fix_Single_Ampersands( &szProductName[0], false );
    //Fix_Single_Ampersands( &szFullProductName[0], false );
    Msg( __LINE__, __FILE__, "szProductName      = %s.", szProductName      );
    WideCharToMultiByte( CodePage, 0, szProductName, _MAX_PATH, szProduct_Name, _MAX_PATH, NULL, NULL );
 
#else
 
    productName = TheGameText->fetch("Autorun:Generals");
    fullProductName = TheGameText->fetch("Autorun:Command&ConquerGenerals");
  Msg( __LINE__, __FILE__, "Product Name = %ls.", productName.str() );
    Msg( __LINE__, __FILE__, "Full Product Name = %ls.", fullProductName.str()    );
    Msg( __LINE__, __FILE__, "szRegistryKey      = %s.", szRegistryKey      );
    Msg( __LINE__, __FILE__, "szGameWindow       = %s.", szGameWindow        );
    WideCharToMultiByte( CodePage, 0, productName.str(), productName.getLength()+1, szProduct_Name, _MAX_PATH, NULL, NULL );
 
#endif
 
    sprintf( szClassName, CLASS_NAME, szProduct_Name );
    MainWindow::Reset_Class_Name( szClassName );
    sprintf( szSetupWindow, SETUP_MAIN_WINDOW_NAME, szProduct_Name );
 
    Msg( __LINE__, __FILE__, "szClassName        = %s.", szClassName      );
    Msg( __LINE__, __FILE__, "szSetupWindow      = %s.", szSetupWindow  );
 
    //=========================================================================
    //  Create a mutex with a unique name to Autorun in order to determine if
    //  our app is already running.
    //
    //  Return Values:
    //  If the function succeeds, the return value is a handle to the mutex object. 
    //  If the named mutex object existed before the function call, the function returns 
    //  a handle to the existing object and GetLastError returns ERROR_ALREADY_EXISTS. 
    //  Otherwise, the caller created the mutex. 
    //  If the function fails, the return value is NULL. To get extended error 
    //  information, call GetLastError. 
    //
    // WARNING: DO NOT use this number for any other application except Autorun
    //=========================================================================
    if( WinVersion.Is_Win_XP() || WinVersion.Version() > 500 ) {
        strcat( strcpy( szBuffer, "Global\\" ), AUTORUN_MUTEX_OBJECT );
    } else {
        strcpy( szBuffer, AUTORUN_MUTEX_OBJECT );
    }
    AppMutex = CreateMutex( NULL, FALSE, szBuffer );
 
    if ( AppMutex != NULL && ( GetLastError() == ERROR_ALREADY_EXISTS )) {
 
        Msg( __LINE__, __FILE__, "AppMutex of %s already exists. Exit here.", szBuffer );
 
        //---------------------------------------------------------------------
        // Handle is closed in the ProgEnd().
        //---------------------------------------------------------------------
 
        //---------------------------------------------------------------------
        // Check if Game/Setup is already running, and is looking for the CDRom.
        //---------------------------------------------------------------------
        HWND prev = FindWindow( szClassName, NULL );
        if( prev ){
            //if( IsIconic( prev )){
                //ShowWindow( prev, SW_RESTORE );
            //}
            SetForegroundWindow( prev );
        }
        return 0;
    }
    Msg( __LINE__, __FILE__, "AppMutex of %s created.", szBuffer );
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // if AppMutex was NULL, let through. Perhaps in future we want to trap it?
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    if ( AppMutex == NULL ) {
    }
 
    //=========================================================================
    //  Create a mutex with a unique name to Game/Setup in order to 
    //  determine if our app is already running.
    //
    //  Return Values
    //  If the function succeeds, the return value is a handle to the mutex object.
    //  If the function fails, the return value is NULL. To get extended error 
    //  information, call GetLastError. 
    //
    // WARNING: DO NOT use this number for any other application except Game/Setup.
    //=========================================================================
    if( WinVersion.Is_Win_XP() || WinVersion.Version() > 500 ) {
        strcat( strcpy( szBuffer, "Global\\" ), GAME_MUTEX_OBJECT );
    } else {
        strcpy( szBuffer, GAME_MUTEX_OBJECT );
    }
    GameAppMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, szBuffer );
 
    if ( GameAppMutex != NULL ) {
 
        Msg( __LINE__, TEXT(__FILE__), TEXT("Mutex Object of game found."));
        Msg( __LINE__, TEXT(__FILE__), TEXT("Looking for Game Window."));
 
        HWND ccwindow = FindWindow( szGameWindow, NULL );
        if ( ccwindow ) {
    
            Msg( __LINE__, TEXT(__FILE__), TEXT("Found Game Window."));
            
            if( IsIconic( ccwindow )){
                ShowWindow( ccwindow, SW_RESTORE );
            }
            SetForegroundWindow( ccwindow );
 
        } else {
 
            Msg( __LINE__, TEXT(__FILE__), TEXT("Looking for Setup Window."));
 
            ccwindow = FindWindow( szSetupWindow, NULL );
            if ( ccwindow ) {
 
                Msg( __LINE__, TEXT(__FILE__), TEXT("Found Setup Window."));
 
                if( IsIconic( ccwindow )){
                    ShowWindow( ccwindow, SW_RESTORE );
                }
                BOOL result = SetForegroundWindow( ccwindow );
                Msg( __LINE__, TEXT(__FILE__), TEXT("SetForegroundWindow = %d."), result );
            }
        }
 
        //---------------------------------------------------------------------
        // Handle(s) are closed in the ProgEnd().
        //---------------------------------------------------------------------
 
        return 0;
    }
 
    //---------------------------------------------------------------------
    // Check if Game/Setup is already running, and is looking for the CDRom.
    //---------------------------------------------------------------------
    HWND prev = FindWindow( szClassName, NULL );
    if ( prev == NULL ) {
        prev = FindWindow( szGameWindow, NULL );
        if ( prev == NULL ) {
            prev = FindWindow( szSetupWindow, NULL );
        }
    }
    if( prev ){
        if( IsIconic( prev )){
            ShowWindow( prev, SW_RESTORE );
        }
        SetForegroundWindow( prev );
 
        Msg( __LINE__, __FILE__, "Either same app, game or setup was found. Exit and set window to foreground." );
        return 0;
    }
 
    //---------------------------------------------------------------------
    // Check if another installshield session is already running.  This happens
    // because we ask the user to insert CD-1 again at the end of the install
    // to prevent a crash on Windows ME where it tries to access CD-1 again.
    //---------------------------------------------------------------------
    prev = FindWindow( NULL,"InstallShield Wizard");
    if( prev ){
        return 0;
    }
 
    //=========================================================================
    // Select Sounds.
    //=========================================================================
    memset( szButtonWav, '\0', _MAX_PATH );
    _tcscpy( szButtonWav, _TEXT( MOUSE_WAV ));
 
//  memset( szSpeechWav, '\0', _MAX_PATH );
//  _tcscpy( szSpeechWav, _TEXT( AUTORUN_WAV ));
 
    if( LanguageID == LANG_USA ) {
 
        strcpy( szWavs[0], SOUND_FILE1 );
        strcpy( szWavs[1], SOUND_FILE2 );
 
        // Pick a number between 0 and 1.  ( NUM_SONGS - 1 )
        // Seed the random-number generator with current time so that
        // the numbers will be different every time we run.
 
        Msg( __LINE__, __FILE__, "szWav[0] = %s.", szWavs[0] );
        Msg( __LINE__, __FILE__, "szWav[1] = %s.", szWavs[1] );
 
        srand(( unsigned )time( NULL ));
        SongNumber    = rand() & 1;
//      UseSounds   = TRUE;
 
        Msg( __LINE__, __FILE__, "SongNumber  = %d.", SongNumber );
        Msg( __LINE__, __FILE__, "UseSounds   = %d.", UseSounds );
    }
 
    //-------------------------------------------------------------------------
    // Get the CD volume to check on which CD in the product we are on.
    //-------------------------------------------------------------------------
//  strcpy( szBuffer, Args->Get_argv(0));
//  CDList.Get_Volume_For_This_CD_Drive( szBuffer, szVolumeName );
 
//  Msg( __LINE__, __FILE__, "szVolumeName  = %s.", szVolumeName );
 
    //-------------------------------------------------------------------------
    // Check if we are on the CD-ROM and in Windows 95.
    //-------------------------------------------------------------------------
    if ( !Valid_Environment(  )) {
        return( -1 );
    }
 
    //=========================================================================
    // Lock the CD!
    //=========================================================================
//  memset( szPath, '\0', _MAX_PATH );
//  szPath[0] = (char)( toupper( szArgvPath[0] ));
//  strcat( szPath, ":\\" );
 
    //-------------------------------------------------------------------------
    // NOTE: Based on A=0, B=1, etc.
    //-------------------------------------------------------------------------
//#if(!PRETEND_ON_CD_TEST)
    char driveLetter = Args->Get_argv(0)[0];
    Msg( __LINE__, TEXT(__FILE__), TEXT("About to lock on CD: %c:\\ "), toupper( driveLetter ));
//  CDLocked = CDControl.Lock_CD_Tray((unsigned)( toupper( szPath[0] ) - 'A' ));
    CDLocked = CDControl.Lock_CD_Tray((unsigned)( toupper( driveLetter ) - 'A' ));
    Msg( __LINE__, TEXT(__FILE__), TEXT("CDLocked = %d. "), CDLocked );
//#endif
 
    //=========================================================================
    // Set the buttons images. Use when images are unique for each button.
    //=========================================================================
    strcpy( ButtonImages[0], BUTTON_REG );
    strcpy( ButtonImages[1], BUTTON_REG );
    strcpy( ButtonImages[2], BUTTON_REG );
    strcpy( ButtonImages[3], BUTTON_REG );
    strcpy( ButtonImages[4], BUTTON_REG );
    strcpy( ButtonImages[5], BUTTON_REG );
    strcpy( ButtonImages[6], BUTTON_REG );
    strcpy( ButtonImages[7], BUTTON_REG );
    strcpy( ButtonImages[8], BUTTON_REG );
    strcpy( ButtonImages[9], BUTTON_REG );
 
    strcpy( FocusedButtonImages[0], BUTTON_SEL );
    strcpy( FocusedButtonImages[1], BUTTON_SEL );
    strcpy( FocusedButtonImages[2], BUTTON_SEL );
    strcpy( FocusedButtonImages[3], BUTTON_SEL );
    strcpy( FocusedButtonImages[4], BUTTON_SEL );
    strcpy( FocusedButtonImages[5], BUTTON_SEL );
    strcpy( FocusedButtonImages[6], BUTTON_SEL );
    strcpy( FocusedButtonImages[7], BUTTON_SEL );
    strcpy( FocusedButtonImages[8], BUTTON_SEL );
    strcpy( FocusedButtonImages[9], BUTTON_SEL );
 
    //=========================================================================
    // A Windows class should be registered with Windows before any windows 
    // of that type are created. Register here all Windows classes that 
    // will be used in the program.
    //-------------------------------------------------------------------------
    // Register the class only AFTER WinMain assigns appropriate values to 
    // static members of Main and only if no previous instances of the program 
    // exist (a previous instance would have already performed the registration).
    //=========================================================================
    if ( !Main::hPrevInstance ) {
        MainWindow::Register();
    }
 
    //-------------------------------------------------------------------------
    // Create MainWnd, calls MainWindow Constructor.
    //-------------------------------------------------------------------------
    MainWindow MainWnd;
 
    //-------------------------------------------------------------------------
    // Begin processing Window Messages.
    //-------------------------------------------------------------------------
    return( Main::MessageLoop( ));
}
 
//*****************************************************************************
// Prog_End -- Close all objects that were created.
//
// INPUT:           none.
//
// OUTPUT:          int.
//
// WARNINGS:        none.
//
// HISTORY:
//   01/22/2001  MML : Created.
//=============================================================================
 
void Prog_End ( void )
{
    //==========================================================================
    // UnLock the CD!
    //==========================================================================
    if( CDLocked ) {
        CDControl.Unlock_CD_Tray((unsigned)( toupper( szArgvPath[0] ) - 'A' ));
        CDLocked = false;
    }
 
    if( Args != NULL ) {
        delete( Args );
        Args = NULL;
        Msg( __LINE__, __FILE__, "Args deleted." );
    }
 
    if ( AppMutex != NULL ) {
        CloseHandle( AppMutex );
        AppMutex = NULL;
        Msg( __LINE__, __FILE__, "AppMutex deleted." );
    }
 
    if ( GameAppMutex != NULL) {
        CloseHandle( GameAppMutex );
        GameAppMutex = NULL;
    }
 
    if ( FontManager != NULL ) {
        delete( FontManager );
        FontManager = NULL;
        Msg( __LINE__, __FILE__, "FontManager deleted." );
    }
 
    if ( OnlineOptions != NULL ) {
        delete( OnlineOptions );
        OnlineOptions = NULL;
        Msg( __LINE__, __FILE__, "OnlineOptions deleted." );
    }
 
    //-------------------------------------------------------------------------
    // Delete language resource file.
    //-------------------------------------------------------------------------
    Locale_Restore();
 
    Debug_Date_And_Time_Stamp();
}
 
 
//*****************************************************************************
// Main::MessageLoop -- Dispatch Message Loop.
//
// INPUT:           none.
//
// OUTPUT:          int.
//
// WARNINGS:        none.
//
// HISTORY:
//   06/04/1996  MML : Created.
//=============================================================================
 
int Main::MessageLoop( void )
{
    MSG msg;
 
    while( GetMessage( &msg, NULL, 0, 0 )) {
        TranslateMessage( &msg );
        DispatchMessage( &msg );
    }
 
    //--------------------------------------------------------------------------
    // Stop the sound if still going.
    //--------------------------------------------------------------------------
    Stop_Sound_Playing();
 
    //==========================================================================
    // UnLock the CD!
    //==========================================================================
//#if(!PRETEND_ON_CD_TEST)
    if( CDLocked ) {
        CDControl.Unlock_CD_Tray((unsigned)( toupper( szArgvPath[0] ) - 'A' ));
        CDLocked = false;
    }
//#endif
 
    //==========================================================================
    // Something to launch?
    //==========================================================================
    if( LaunchObject.Launch_A_Program()) {
        LaunchObject.Launch();
    }
 
    return( msg.wParam );
}
 
 
//*****************************************************************************
// MainWindow::Register -- Register the Main Window.
//
// INPUT:           none.
//
// OUTPUT:          none.
//
// WARNINGS:        none.
//
// HISTORY:
//   06/04/1996  MML : Created.
//=============================================================================
 
void MainWindow::Register( void )
{
    //--------------------------------------------------------------------------
    // Structure used to register Windows class.
    //--------------------------------------------------------------------------
    WNDCLASSEX wndclass;
 
    //--------------------------------------------------------------------------
    // set up and register window class
    //--------------------------------------------------------------------------
    wndclass.cbSize         = sizeof(WNDCLASSEX);
    wndclass.style          = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc    = Wnd_Proc;
    wndclass.cbClsExtra     = 0;
 
    //--------------------------------------------------------------------------
    // Reserve extra bytes for each instance of the window. We will use these
    // bytes to store a pointer to the C++ (MainWindow) object corresponding
    // to the window. The size of a 'this' pointer depends on the memory model.
    //--------------------------------------------------------------------------
    wndclass.cbWndExtra     = sizeof( MainWindow * );
    wndclass.hInstance      = Main::hInstance;
    wndclass.hIcon          = LoadIcon( Main::hInstance, MAKEINTRESOURCE(1));
 
//  strcpy( szBuffer, "C&C2.ICO" );
//  wndclass.hIcon  = (HICON)LoadImage( NULL, szBuffer, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_LOADFROMFILE );
 
    wndclass.hCursor        = LoadCursor( Main::hInstance, MAKEINTRESOURCE(2) );
    wndclass.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
    wndclass.lpszMenuName   = szClassName;
    wndclass.lpszClassName  = szClassName;
    wndclass.hIconSm        = LoadIcon( Main::hInstance, MAKEINTRESOURCE(1));
 
    if ( !RegisterClassEx((const WNDCLASSEX *) &wndclass ) ) {
 
    #if(_DEBUG)
        LPVOID szMessage; 
 
        FormatMessage( 
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 
            NULL,
            GetLastError(), 
            MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
            (LPTSTR)&szMessage,
            0,
            NULL );
 
        _stprintf( szBuffer, TEXT( "%s(%lx)" ), szMessage, GetLastError()); 
        Msg( __LINE__, TEXT(__FILE__), TEXT("GetLastError: %s"), szBuffer );
    #endif
 
        exit( FALSE );
    }
}
 
//*****************************************************************************
// MainWindow::MainWindow -- Main Window Constructor function.                  
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
MainWindow::MainWindow( void )
{
    char szTitle[ _MAX_PATH ];
    hWnd = 0;
 
#ifdef LEAN_AND_MEAN
 
    WideCharToMultiByte( CodePage, 0, szFullProductName, _MAX_PATH, szBuffer, _MAX_PATH, NULL, NULL );
 
#else
 
    WideCharToMultiByte( CodePage, 0, fullProductName.str(), fullProductName.getLength()+1, szBuffer, _MAX_PATH, NULL, NULL );
 
#endif
 
    memset( szTitle, '\0', _MAX_PATH );  
    sprintf( szTitle, CLASS_NAME, szBuffer );
 
    //--------------------------------------------------------------------------
    // Create the MainWindow.
    // Pass 'this' pointer in lpParam of CreateWindow().
    //--------------------------------------------------------------------------
    hWnd = CreateWindowEx(
                0,
                szClassName, 
                szClassName,
                WS_POPUPWINDOW | WS_MINIMIZE | !WS_VISIBLE,
                0, 
                0,
                640,
                480,
                NULL, 
                NULL, 
                Main::hInstance, 
                (LPTSTR) this );
 
    if ( !hWnd ) {
        Stop_Sound_Playing();
        exit( FALSE );
    }
 
    ApplicationHWnd = hWnd;
 
    //-------------------------------------------------------------------------
    // Save the pointer so we can access it globally.
    //-------------------------------------------------------------------------
    GlobalMainWindow = this;
 
    //--------------------------------------------------------------------------
    // If you want to see the Background Window, enable these.
    //--------------------------------------------------------------------------
//  Show( Main::nCmdShow );
//  Update();
}
 
//*****************************************************************************
// MainWindow::Window_Proc -- Main Window Procedure fnc to process msgs.    
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
LRESULT MainWindow::Window_Proc( HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam )
{
    static  RECT    rect;
    static  int     cxChar, cyChar;
    static  HBRUSH  hBrush = 0;
    static  POINT   point;
    int             decision;
    static  int     bits_pixel = 0;
 
    switch( iMessage ) {
 
        //-----------------------------------------------------------------------
        // Create Message.
        //-----------------------------------------------------------------------
        case WM_CREATE:
            #if(0)
                hBrush = CreateSolidBrush( GetSysColor( COLOR_WINDOW ));
            #endif
            GetClientRect( GetDesktopWindow(), &rect );
            SendMessage( hWnd, WM_GO, wParam, lParam );
            break;
 
        //-----------------------------------------------------------------------
        // Go!
        //-----------------------------------------------------------------------
        case WM_GO:
 
            decision = DialogBox( Main::hInstance, _TEXT( "BitmapDialog" ), hWnd, Dialog_Box_Proc );
 
            if ( Args ) {
                delete( Args );
                Args = NULL;
            }
            Stop_Sound_Playing();
 
            MoveWindow( hWnd, 0, 0, 0, 0, TRUE );
            SendMessage( hWnd, WM_DESTROY, wParam, lParam );
            Msg( __LINE__, TEXT(__FILE__), TEXT("---------------------- end of WM_GO ---------------------" ));
            break;
 
        //-----------------------------------------------------------------------
        // WM_CTLCOLOR Message.
        // wParam               Handle to Child Window's device context
        // LOWORD( lParam )     Child Window handle
        // HIWORD( lParam )     Type of Window:     CTLCOLOR_MSGBOX, _EDIT, _LISTBOX, _BTN, _DLG, _SCROLLBAR, _STATIC
        //-----------------------------------------------------------------------
    #if( WINDOW_BRUSH )
        case WM_CTLCOLOR:
            if ( HIWORD( lParam ) == CTLCOLOR_BTN ) {
                SetBkColor( (HDC)wParam, GetSysColor( COLOR_WINDOW ));
                SetTextColor( (HDC)wParam, GetSysColor( COLOR_WINDOWTEXT ));
                UnrealizeObject( hBrush );                          // reset the origin of the brush next time used.
                point.x = point.y = 0;                              // create a point.
                ClientToScreen( hWnd, &point );                     // translate into screen coordinates.
                SetBrushOrg( (HDC)wParam, point.x, point.y );       // New Origin to use when next selected.
                return ((DWORD) hBrush);
            }
            break;
 
        //-----------------------------------------------------------------------
        // WM_SYSCOLORCHANGE Message.
        //-----------------------------------------------------------------------
        case WM_SYSCOLORCHANGE:
            DeleteObject( hBrush );
            hBrush = CreateSolidBrush( GetSysColor( COLOR_WINDOW ));
            break;
 
        //-----------------------------------------------------------------------
        // WM_SIZE Message.
        //-----------------------------------------------------------------------
        case WM_SIZE:
            rect.left   = 24 * cxChar;
            rect.top    = 2 * cyChar;
            rect.right  = LOWORD( lParam );
            rect.bottom = HIWORD( lParam );
            break;
    #endif
 
        //-----------------------------------------------------------------------
        // WM_COMMAND Message.
        // wParam               Child Window ID
        // LOWORD( lParam )     Child Window handle
        // HIWORD( lParam )     Notification Code: BN_CLICKED, BN_PAINT, etc...
        //-----------------------------------------------------------------------
        case WM_COMMAND:  
            break;
 
        //-----------------------------------------------------------------------
        // WM_DESTROY Message.
        //-----------------------------------------------------------------------
        case WM_DESTROY:
            #if(WINDOW_BRUSH)
                DeleteObject( hBrush );
            #endif
            PostQuitMessage( 0 );
            break;
 
        default:
            return DefWindowProc( hWnd, iMessage, wParam, lParam );
    }
    return 0;
}
 
 
//*****************************************************************************
// MainWindow::Is_Product_Registered -- Check the Registration Table information.
//
// INPUT:       none.
//                                                                 
//  OUTPUT:         BOOL - TRUE if product is already installed, FALSE if not.
//                                                                 
// WARNINGS:    none.
//                                                                 
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
BOOL MainWindow::Is_Product_Registered( void )
{
    HKEY    phKey;
    BOOL    result = FALSE;
 
    char        key         [_MAX_PATH];
    wchar_t     szPath      [_MAX_PATH];
    char        aName       [_MAX_PATH];            //jfs
 
    unsigned long Type;
    unsigned long Size = _MAX_PATH;
 
    HANDLE  handle;
    WIN32_FIND_DATA FindFileData;
 
    memset( szPath,         '\0', sizeof( szPath ));
    memset( szGamePath,       '\0', sizeof( szGamePath ));
    memset( szSetupPath, '\0', sizeof( szSetupPath ));
    memset( szRegisterPath, '\0', sizeof( szRegisterPath ));
    memset( szInternetPath, '\0', sizeof( szInternetPath ));
    memset( szUninstallPath,     '\0', sizeof( szUninstallPath ));
    memset( szUninstallCommandLine, '\0', sizeof( szUninstallCommandLine ));
    memset( FindFileData.cFileName, '\0', sizeof( FindFileData.cFileName ));
    memset( FindFileData.cAlternateFileName, '\0', sizeof( FindFileData.cAlternateFileName ));
 
    InstallProduct            = TRUE;
    UninstallAvailable        = FALSE;
    DisplayRegisterButton  = FALSE;
    IsWolapiAvailable      = FALSE;
    IsUserRegistered        = FALSE;
 
    //==========================================================================
    // Look for keys under the Game's Registry key.
    //==========================================================================
//  _tcscat( _tcscpy( key, SOFTWARE_EAGAMES_KEY ), szRegistryKey );
    _tcscat( _tcscpy( key, EAGAMES_GENERALS_KEY ), szRegistryKey );
 
    //--------------------------------------------------------------------------
    // Try to open the key.
    //--------------------------------------------------------------------------
    if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_QUERY_VALUE, &phKey ) == ERROR_SUCCESS ) {
 
        //-----------------------------------------------------------------------
        // Get Full path\filename of product to execute ("Play").
        //-----------------------------------------------------------------------
        Size = _MAX_PATH;
        if ( RegQueryValueEx( phKey, INSTALL_PATH_KEY, NULL, &Type, (unsigned char *)szGamePath, &Size ) == ERROR_SUCCESS ) {
            _tcscpy(szWorldbuilderPath, szGamePath);
            _tcscpy(szPatchgetPath, szGamePath);
            _tcscat(szGamePath, LAUNCHER_FILENAME);
            _tcscat(szWorldbuilderPath, WORLDBUILDER_FILENAME);
            _tcscat(szPatchgetPath, PATCHGET_FILENAME);
            handle = FindFirstFile( szGamePath, &FindFileData );
            if ( handle != INVALID_HANDLE_VALUE ) {
                InstallProduct = FALSE;
                FindClose( handle );    
            }
        }
        Msg( __LINE__, TEXT(__FILE__), TEXT("GamePath =  %s."), szGamePath );
 
        RegCloseKey( phKey );
    }
 
    //==========================================================================
    // Find Keys under "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
    //==========================================================================
 
    _tcscpy( key, SHELL_UNINSTALL_KEY );
    Path_Add_Back_Slash( key );
    _tcscat( key, szRegistryKey );
 
    //--------------------------------------------------------------------------
    // Query the Uninstall key "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
    //--------------------------------------------------------------------------
    if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_ALL_ACCESS, &phKey ) == ERROR_SUCCESS ) {
 
        Size = _MAX_PATH;
        if ( RegQueryValueEx( phKey, UNINSTALL_STRING_SUBKEY, NULL, &Type, (unsigned char *)aName, &Size ) == ERROR_SUCCESS ) 
        {
            //------------------------------------------------------------------------------------------------------
            // Look for the uninstall program.  If found, set flag.
            // JFS... need to extract path and command line...  8/26/03
            // JFS... further verify that we use a very limited uninstall based on the presence of "IDriver.exe"
            //------------------------------------------------------------------------------------------------------
            if(strstr(aName,UNINSTALL_EXECUTABLE) != NULL)
            {
                char    *sp;
                
                strcpy( szUninstallPath, aName );
                sp = strchr(szUninstallPath,'/');
                if(*sp != NULL)
                {
                    strcpy( szUninstallCommandLine, sp );
                    strcpy( szUninstallPath, aName );
                    *sp = '\0';
                }       
            }
                
            handle = FindFirstFile( szUninstallPath, &FindFileData );
            if ( handle != INVALID_HANDLE_VALUE ) {
                UninstallAvailable = TRUE;
                FindClose( handle );    
            }
        }
        RegCloseKey( phKey );
    }
 
    //==========================================================================
    // Look for keys under Register.  If available, we should show the "Register"
    // button.  WESTWOOD_REGISTER_KEY "Software\\Westwood\\Register"
    //==========================================================================
//  _tcscpy( key, WESTWOOD_REGISTER_KEY );
 
    //-------------------------------------------------------------------------
    // Create IGR Options Object.
    //-------------------------------------------------------------------------
    IGROptionsClass *OnlineOptions = new IGROptionsClass();
    if ( OnlineOptions ) {
        OnlineOptions->Init();
    }
 
    //--------------------------------------------------------------------------
    // If "Options" is set under WOLAPI, then this is a Game Room Edition and
    // registration should NOT be allowed.
    //--------------------------------------------------------------------------
    if ( OnlineOptions ) {
        DisplayRegisterButton = OnlineOptions->Is_Running_Reg_App_Allowed();
    }
 
    //--------------------------------------------------------------------------
    // If Registration is allowed...
    //--------------------------------------------------------------------------
/*
    if ( DisplayRegisterButton ) {
 
        DisplayRegisterButton = false;
 
        if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_QUERY_VALUE, &phKey ) == ERROR_SUCCESS ) {
 
            //-----------------------------------------------------------------------
            // Get Full path\filename of product to execute ("Register.exe").
            //-----------------------------------------------------------------------
            Size = _MAX_PATH;
            if ( RegQueryValueEx( phKey, INSTALLPATH_SUBKEY, NULL, &Type, (unsigned char *)szRegisterPath, &Size ) == ERROR_SUCCESS ) {
 
                //--------------------------------------------------------------------
                // Check if this executable exists.
                //--------------------------------------------------------------------
                handle = FindFirstFile( szRegisterPath, &FindFileData );
                if ( handle != INVALID_HANDLE_VALUE ) {
                    DisplayRegisterButton = TRUE;
                    FindClose( handle );    
                }
            }
            RegCloseKey( phKey );
        }
    }
*/
    //==========================================================================
    // Is WOLAPI DLL installed?
    //==========================================================================
/*
    _tcscpy( key, WESTWOOD_WOLAPI_KEY );
 
    if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_QUERY_VALUE, &phKey ) == ERROR_SUCCESS ) {
 
        //-----------------------------------------------------------------------
        // Get Full path\filename of product to execute ("Register.exe").
        //-----------------------------------------------------------------------
        Size = _MAX_PATH;
        if ( RegQueryValueEx( phKey, INSTALLPATH_SUBKEY, NULL, &Type, (unsigned char *)szBuffer, &Size ) == ERROR_SUCCESS ) {
 
            //--------------------------------------------------------------------
            // Check if this executable exists.
            //--------------------------------------------------------------------
            handle = FindFirstFile( szBuffer, &FindFileData );
            if ( handle != INVALID_HANDLE_VALUE ) {
                IsWolapiAvailable = TRUE;
                FindClose( handle );    
            }
        }
        RegCloseKey( phKey );
    }
*/
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("---------------- Is_Product_Registered---------------" ));
    Msg( __LINE__, TEXT(__FILE__), TEXT(" InstallProduct     = %d."), InstallProduct   );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" UninstallAvailable = %d."), UninstallAvailable   );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" IsUserRegistered       = %d."), IsUserRegistered );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" DisplayRegisterButton  = %d."), DisplayRegisterButton );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" szGamePath         = %s."), szGamePath   );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" szSetupPath            = %s."), szSetupPath );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" szRegisterPath     = %s."), szRegisterPath   );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" szInternetPath     = %s."), szInternetPath   );
    Msg( __LINE__, TEXT(__FILE__), TEXT(" szUninstallPath        = %s."), szUninstallPath );
 
    return( result );
}
 
 
//*****************************************************************************
// MainWindow::Run_Explorer
//
//      Get the Current Dir from argv[0].  Open the Explorer Window with
//      this dir.  The Explorer will open and display everything in this dir.
//
//  INPUT:      none.
//
//  OUTPUT:     none.
//
//  WARNINGS:   none.
//
//  HISTORY:                                                                
//      06/04/1996  MML : Created.                                            
//=============================================================================
 
BOOL MainWindow::Run_Explorer( char *szString, HWND hWnd, RECT *rect )
{
    char    szWindowsPath   [ _MAX_PATH ];
    char    szPath          [ _MAX_PATH ];
    char    szCurDir        [ _MAX_PATH ];
    char    drive              [ _MAX_DRIVE ];
    char    dir              [ _MAX_DIR ];
    char    lpszComLine     [ 127 ];
 
    BOOL result = FALSE;
    PROCESS_INFORMATION processinfo; 
    STARTUPINFO startupinfo;
 
    //--------------------------------------------------------------------------
    // Get current drive/directory from _argv[0].
    //--------------------------------------------------------------------------
    _tcscpy( szPath, szArgvPath );
    _tsplitpath( szPath, drive, dir, NULL, NULL );
    _tmakepath ( szPath, drive, dir, NULL, NULL );
 
    //--------------------------------------------------------------------------
    // Get Windows directory and build path to Explorer.  Pas in szPath as
    // the directory for Explorer to open.
    //--------------------------------------------------------------------------
    GetWindowsDirectory( szWindowsPath, _MAX_PATH );
    Path_Add_Back_Slash( szWindowsPath );
 
    _tcscat( szWindowsPath, EXPLORER_NAME );
    _tcscat( _tcscat( _tcscpy( lpszComLine, szWindowsPath ), _TEXT( " " )), szPath );
    _tcscpy( szCurDir, szPath );
 
    //==========================================================================
    // Setup the call
    //==========================================================================
    memset( &startupinfo, 0, sizeof( STARTUPINFO ));
    startupinfo.cb = sizeof( STARTUPINFO );
 
    //--------------------------------------------------------------------------
    // Next, start the process
    //--------------------------------------------------------------------------
    result = CreateProcess( 
                szWindowsPath,              // address of module name
                lpszComLine,                // address of command line
                NULL,                       // address of process security attributes
                NULL,                       // address of thread security attributes
                FALSE,                     // new process inherits handles
                0,                          // creation flags
                NULL,                       // address of new environment block
                szCurDir,                   // address of current directory name
                &startupinfo,               // address of STARTUPINFO
                &processinfo );             // address of PROCESS_INFORMATION
 
    //--------------------------------------------------------------------------
    // If WinExec returned 0, error occurred.
    //--------------------------------------------------------------------------
    if ( !result ) {
 
        Cant_Find_MessageBox ( Main::hInstance, szPath );
 
    #if(BACKGROUND_BITMAP)
        //-----------------------------------------------------------------------
        // Recreate Buttons based on Registry, then repaint window.
        //-----------------------------------------------------------------------
        Create_Buttons( hWnd, rect );
        InvalidateRect( hWnd, rect, FALSE );
    #endif
    }
    return ( result );
}
 
//*****************************************************************************
// MainWindow::Run_Game -- Launch the game based on registry information.
//
// INPUT:       none.
//
//  OUTPUT:         none.
//
// WARNINGS:    none.
//
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Game ( HWND hWnd, RECT *rect )
{
    char dir     [_MAX_DIR];
    char ext    [_MAX_EXT];
    char drive [_MAX_DRIVE];
    char file   [_MAX_FNAME];
 
//  unsigned abc  = 0;
    HANDLE  handle;
    WIN32_FIND_DATA FindFileData;
 
    //--------------------------------------------------------------------------
    // Check if C&C is already running, and is looking for the CDRom.
    // The Autorun keeps asking to "Play" when this happens.
    //--------------------------------------------------------------------------
    HWND game_window = FindWindow ( szGameWindow, NULL );
    if ( game_window ){
        ShowWindow( game_window, SW_RESTORE );
        SetForegroundWindow ( game_window );
        return FALSE;
    }
 
    //--------------------------------------------------------------------------
    // Split into parts.
    //--------------------------------------------------------------------------
    _tsplitpath( szGamePath, drive, dir, file, ext );
 
    //--------------------------------------------------------------------------
    // Launch the game.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( szGamePath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        return FALSE;
    }
 
    FindClose( handle );    
 
    //-----------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //-----------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( szGamePath );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
//*****************************************************************************
// MainWindow::Run_WorldBuilder -- Launch the map editor based on registry information.
//
// INPUT:       none.
//
//  OUTPUT:         none.
//
// WARNINGS:    none.
//
// HISTORY:                                                                
//   12/02/2002  BGC : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_WorldBuilder( HWND hWnd, RECT *rect)
{
    HANDLE  handle;
    WIN32_FIND_DATA FindFileData;
 
    //--------------------------------------------------------------------------
    // Launch the game.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( szWorldbuilderPath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        return FALSE;
    }
 
    FindClose( handle );    
 
    //-----------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //-----------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( szWorldbuilderPath );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
//*****************************************************************************
// MainWindow::Run_PatchGet -- Launch the patch checker based on registry information.
//
// INPUT:       none.
//
//  OUTPUT:         none.
//
// WARNINGS:    none.
//
// HISTORY:                                                                
//   12/02/2002  BGC : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_PatchGet( HWND hWnd, RECT *rect)
{
    HANDLE  handle;
    WIN32_FIND_DATA FindFileData;
 
    //--------------------------------------------------------------------------
    // Launch the game.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( szPatchgetPath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        return FALSE;
    }
 
    FindClose( handle );    
 
    //-----------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //-----------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( szPatchgetPath );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
//*****************************************************************************
//  MainWindow::Run_Demo -- Launch a demo program if desired.
//
//  INPUT:      none.
//
//  OUTPUT:     none.
//
//  WARNINGS:   none.
//
//  HISTORY:                                                                
//      01/08/2002  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Demo ( HWND hWnd, RECT *rect, int cd_drive )
{
//  unsigned    abc  = 0;
    HANDLE      handle;
    WIN32_FIND_DATA FindFileData;
 
    //--------------------------------------------------------------------------
    // Make path to demo program.
    //--------------------------------------------------------------------------
//  Make_Current_Path_To( MOH_DEMO_PROGRAM, szBuffer );
    wsprintf( szBuffer, "%c:\\", 'A' + cd_drive );
    Path_Add_Back_Slash( szBuffer );
    strcat( szBuffer, MOH_DEMO_PROGRAM );
 
    //--------------------------------------------------------------------------
    // Launch the game.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( szBuffer, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        Cant_Find_MessageBox( Main::hInstance, szBuffer );
        return FALSE;
    }
 
    FindClose( handle );    
 
    //-----------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //-----------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( szBuffer );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
//*****************************************************************************
// MainWindow::Run_OpenFile -- Main Window function to perform Setup tasks.     
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_OpenFile(int cd_drive, const char *filename, bool wait /* = false */)
{
    char filepath[MAX_PATH];
    MSG msg;
    BOOL returnValue;
 
    SHELLEXECUTEINFO executeInfo;
    memset(&executeInfo, 0, sizeof(executeInfo));
 
    executeInfo.cbSize = sizeof(executeInfo);
    executeInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
    executeInfo.hwnd = ApplicationHWnd;
    executeInfo.lpVerb = "open";
    executeInfo.lpFile = filename;
    executeInfo.nShow = SW_SHOWNORMAL;
 
    HANDLE hProcess;
 
 
    BOOL ret = ShellExecuteEx(&executeInfo);
 
    if ((ret == 0) || ((int)(executeInfo.hInstApp) <= 32)) {
        Msg(__LINE__, TEXT(__FILE__), TEXT("Couldn't find executable for %s\n"), filepath);
        return 0;
    }
 
    hProcess = executeInfo.hProcess;
 
    if (wait == true) {
        WaitForInputIdle(hProcess, 5000);
 
        bool waiting = true;
        bool quit = false;
 
        while ((waiting == true) && (quit != true)) {
            Sleep(0);
 
            while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
            {
 
                // get the message
                returnValue = GetMessage( &msg, NULL, 0, 0 );
 
                // check for quitting
                if( returnValue == 0 )
                    quit = TRUE;
 
                // translate and dispatch the message
                TranslateMessage( &msg );
                DispatchMessage( &msg );
 
            }  // end while
 
            DWORD exitCode;
            GetExitCodeProcess(hProcess, &exitCode);
 
            if (exitCode != STILL_ACTIVE) {
                waiting = false;
            }
        }
    }
 
    return 1;
}
 
//*****************************************************************************
// MainWindow::Run_Setup -- Main Window function to perform Setup tasks.        
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Setup( HWND hWnd, RECT *rect, int cd_drive )
{
//  UINT                result = 0;
    int                 i = 0;
    char                params      [ 127 ];
    char                filepath[ _MAX_PATH ];
    HANDLE              handle;
    WIN32_FIND_DATA     FindFileData;
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("---------------------- Run_Setup --------------------." ));
 
    //--------------------------------------------------------------------------
    // Clear these buffers for later use.
    //--------------------------------------------------------------------------
    memset( params, '\0', 127 );
 
    //--------------------------------------------------------------------------
    // Get Drive & Dir from ARGV[0] and create path to SETUP.EXE.
    //--------------------------------------------------------------------------
//  strcpy( filepath, szArgvPath );
//  Path_Add_Back_Slash( filepath );
 
    wsprintf( filepath, "%c:\\", 'A' + cd_drive );
    Path_Add_Back_Slash( filepath );
    strcat( filepath, SETUP_NAME );
 
    //--------------------------------------------------------------------------
    // If we could not find SETUP.EXE, then display error msg and exit.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( filepath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        Cant_Find_MessageBox( Main::hInstance, filepath );
        return FALSE;
    }
    FindClose( handle );    
 
    //--------------------------------------------------------------------------
    //  Create parameters to pass in with the program we are calling.
    //--------------------------------------------------------------------------
    memset( params, '\0', sizeof( params ));
    if ( NumberArguments ) {
 
        _tcscpy( params, Arguments[0] );
        i = 1;
        while (( i < NUM_ARGUMENTS ) && ( i < NumberArguments )) {
            _tcscat( _tcscat( params, _TEXT( " " )), Arguments[i] );
            i++;
        }
    }
 
    //--------------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //--------------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( filepath );
    LaunchObject.SetArgs( params );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
 
//*****************************************************************************
// MainWindow::Run_New_Account -- Create a new online account.      
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_New_Account ( HWND hWnd, RECT *rect )
{
//  UINT    result = 0;
    int     i = 0;
    char    params  [ 127 ];
    char    filepath[ _MAX_PATH ];
    HANDLE  handle;
    WIN32_FIND_DATA FindFileData;
 
    //--------------------------------------------------------------------------
    // Clear these buffers for later use.
    //--------------------------------------------------------------------------
    memset( params, '\0', 127 );
 
    //--------------------------------------------------------------------------
    // Get Drive & Dir from ARGV[0] and create path to SETUP.EXE.
    //--------------------------------------------------------------------------
    _tcscpy( filepath, szArgvPath );
    Path_Add_Back_Slash( filepath );
    _tcscat( filepath, SETUP_NAME );
 
    //--------------------------------------------------------------------------
    // If we could not find SETUP.EXE, then display error msg and exit.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( filepath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        Cant_Find_MessageBox( Main::hInstance, SETUP_NAME );
        return FALSE;
    }
    FindClose( handle );    
 
    //--------------------------------------------------------------------------
    //  Create parameters to pass in with the program we are calling.
    //--------------------------------------------------------------------------
    memset( params, '\0', sizeof( params ));
    if ( NumberArguments ) {
 
        _tcscpy( params, Arguments[0] );
        i = 1;
        while (( i < NUM_ARGUMENTS ) && ( i < NumberArguments )) {
            _tcscat( _tcscat( params, _TEXT( " " )), Arguments[i] );
            i++;
        }
        _tcscat( params, _TEXT( " " ));
    }
    _tcscat( params, "-o" );
 
    //--------------------------------------------------------------------------
    // Stop Sound if sound was playing.
    //--------------------------------------------------------------------------
    Stop_Sound_Playing();
 
    LaunchObject.SetPath( filepath );
    LaunchObject.SetArgs( params );
    LaunchObject.Set_Launch( true );
    return( true );
}
 
 
//*****************************************************************************
// MainWindow::Run_Register_Or_Auto_Update 
//                                         
//      Either run Register.exe or Game Update Program from the user's harddrive.
//                                
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   02/24/1999  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Register ( HWND hWnd, RECT *rect )
{
    char                szArgs[ MAX_PATH ];
    HANDLE              handle;
    WIN32_FIND_DATA     FindFileData;
    BOOL                result = FALSE;
 
    //--------------------------------------------------------------------------
    // Register Program is available.  Continue...
    //--------------------------------------------------------------------------
    if ( DisplayRegisterButton ) {
 
        //-----------------------------------------------------------------------
        // Check again.  May have been changed ...                                       
        //-----------------------------------------------------------------------
        handle = FindFirstFile( szRegisterPath, &FindFileData );
        if ( handle == INVALID_HANDLE_VALUE ) {
            return( 0 );
        }
        FindClose( handle );
 
        //-----------------------------------------------------------------------
        // User is already registered, so maybe we should Auto Update!
        //-----------------------------------------------------------------------
        strcpy( szArgs, _TEXT( " " ));
 
        LaunchObject.SetPath( szRegisterPath );
        LaunchObject.SetArgs( szArgs );
        LaunchObject.Set_Launch( true );
        result = true;
    }
 
    return( result );
}
 
//*****************************************************************************
// MainWindow::Run_Auto_Update
//                                         
//      Either run Register.exe or Game Update Program from the user's harddrive.
//                                
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   02/24/1999  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Auto_Update ( HWND hWnd, RECT *rect )
{
    char                szArgs      [ MAX_PATH ];
    HANDLE              handle;
    WIN32_FIND_DATA     FindFileData;
    BOOL                result = FALSE;
 
    //--------------------------------------------------------------------------
    // Register Program is available.  Continue...
    //--------------------------------------------------------------------------
    if ( !InstallProduct ) {
 
        //-----------------------------------------------------------------------
        // Check again.  May have been changed ...                                       
        //-----------------------------------------------------------------------
        handle = FindFirstFile( szGamePath, &FindFileData );
        if ( handle == INVALID_HANDLE_VALUE ) {
            return( 0 );
        }
        FindClose( handle );
 
        _tcscpy( szArgs, _TEXT( " GrabPatches" ));
 
        LaunchObject.SetPath( szGamePath );
        LaunchObject.SetArgs( szArgs );
        LaunchObject.Set_Launch( true );
        result = true;
    }
    return( result );
}
 
 
//*****************************************************************************
// MainWindow::Run_Uninstall -- Main Window function to perform Setup tasks.        
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
unsigned int MainWindow::Run_Uninstall( HWND hWnd, RECT *rect )
{
//  MSG     msg;
    UINT    result          = 0;
//  int     done            = 0;
//  DWORD   dwTimeout       = 1500;
//  DWORD   dwRC            = WAIT_TIMEOUT;
    DWORD  lpExitCode;
 
    STARTUPINFO             startupinfo;
    PROCESS_INFORMATION     processinfo;
    HANDLE                  handle;
    WIN32_FIND_DATA         FindFileData;
 
    char    szCurDir    [_MAX_PATH];
    char    file        [_MAX_FNAME];
    char    ext         [_MAX_EXT];
    char    szPath      [_MAX_PATH];
 
    //--------------------------------------------------------------------------
    // Launch the UNINSTALL.
    //--------------------------------------------------------------------------
    handle = FindFirstFile( szUninstallPath, &FindFileData );
    if ( handle == INVALID_HANDLE_VALUE ) {
        return( 0 );
    }
 
    FindClose( handle );    
 
    _splitpath( szUninstallPath, drive, dir, NULL, NULL );
    _makepath ( szCurDir, drive, dir, NULL, NULL );
 
    //=======================================================================
    // Setup the call
    //=======================================================================
    memset( &startupinfo, 0, sizeof( STARTUPINFO ));
    startupinfo.cb = sizeof( STARTUPINFO );
 
    result = CreateProcess( 
                    szUninstallPath,         // address of module name
                    szUninstallCommandLine,       // address of command line
                    NULL,                       // address of process security attributes
                    NULL,                       // address of thread security attributes
                    0,                          // new process inherits handles
                    0,
                    NULL,                       // address of new environment block
                    szCurDir,
                    &startupinfo,               // address of STARTUPINFO
                    &processinfo );             // address of PROCESS_INFORMATION
 
    //--------------------------------------------------------------------------
    // If WinExec returned 0, error occurred.
    //--------------------------------------------------------------------------
    if ( !result ) {
 
        _tsplitpath( szUninstallPath, NULL, NULL, file, ext );
        _tmakepath ( szPath, NULL, NULL, file, ext );
        Cant_Find_MessageBox ( Main::hInstance, szPath );
 
//  #if(BACKGROUND_BITMAP)
        //-----------------------------------------------------------------------
        // Recreate Buttons based on Registry, then repaint window.
        //-----------------------------------------------------------------------
//      Create_Buttons( hWnd, rect );
//      InvalidateRect( hWnd, rect, FALSE );
//  #endif
 
        return( result );
    }
 
    // JFS: 8-26-03... Can't have auto run going during an uninstall!
#if 0
    //--------------------------------------------------------------------------
    // Wait for App to shutdown
    //--------------------------------------------------------------------------
    while (dwRC == WAIT_TIMEOUT)  
    {
 
        //-----------------------------------------------------------------------
        // Wait for object
        //-----------------------------------------------------------------------
        dwRC = WaitForSingleObject( processinfo.hProcess, dwTimeout );
 
 
        //-----------------------------------------------------------------------
        // Flush the Queue
        //-----------------------------------------------------------------------
        while (PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ))  {
            TranslateMessage( &msg );
//          DispatchMessage( &msg );
        }
    }
#endif
    //--------------------------------------------------------------------------
    // If the specified process has not terminated, the termination status 
    // returned is STILL_ACTIVE.    
    //--------------------------------------------------------------------------
    GetExitCodeProcess( processinfo.hProcess, &lpExitCode );
    CloseHandle( processinfo.hProcess ); 
    CloseHandle( processinfo.hThread  ); 
 
#if(BACKGROUND_BITMAP)
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // MML 5/27/99:  This function is dropping through because we launch Uninstll.exe 
    // which in turn launches Uninst.exe thus ::Run_Install ends before Uninst.exe is done.
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
    //--------------------------------------------------------------------------
    // Recreate Buttons based on Registry.
    // Repaint calling Window.
    //--------------------------------------------------------------------------
    Create_Buttons( hWnd, rect );
    InvalidateRect( hWnd, rect, FALSE );
#endif
 
    return( result );
}
 
//*****************************************************************************
// MainWindow::Create_Buttons -- Reset the Buttons.
//                                                                         
// INPUT:         none.                                                                     
//                                                                                                  
// OUTPUT:        none.                                                    
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
void MainWindow::Create_Buttons( HWND hWnd, RECT *dlg_rect )
{
    int j = 0;
    int i = 0;
    int x_pos = 0;
    int y_pos = 0;
    int width = 0;
    int height = 0;
    int button_index = 0;
 
    HBITMAP     hButtonBitmap  = 0;
    HPALETTE    hpal = 0;
    BITMAP      button_bm;
    char        next_button_name[_MAX_PATH];
    char        focused_button_name[_MAX_PATH];
    RECT *      button_size = ButtonSizes;
 
    //--------------------------------------------------------------------------
    // Reset all the flags.
    //--------------------------------------------------------------------------
    Is_Product_Registered( );
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("------------------------ Create_Buttons ------------------------" ));
 
    //--------------------------------------------------------------------------
    // Get width and height of the button.
    //--------------------------------------------------------------------------
    hButtonBitmap = LoadResourceBitmap( Main::hModule, BUTTON_REG, &hpal, TRUE );
    if ( hButtonBitmap ) {
        GetObject( hButtonBitmap, sizeof( BITMAP ), (LPTSTR)&button_bm );
        width   = button_bm.bmWidth;
        height  = button_bm.bmHeight;
        DeleteObject( hButtonBitmap );
        hButtonBitmap = 0;
    } else {
        button_bm.bmWidth   = width     = BUTTON_WIDTH;
        button_bm.bmHeight  = height    = BUTTON_HEIGHT;
    }
 
    //--------------------------------------------------------------------------
    // Initialize the ButtonList.
    //--------------------------------------------------------------------------
    if( b640X480 || b800X600 ) {
 
        x_pos   = 410;
        y_pos   = 90;
    } else {
        x_pos   = 540;
        y_pos   = 117;
    }
 
    for ( i = 0; i < NUM_BUTTONS; i++ ) {
 
        if ( ButtonList[i] ) 
        {
            delete( ButtonList[i] );
        }
 
        ButtonList[i]         = NULL;
        ButtonSizes[i].left      = x_pos;                // X position.
        ButtonSizes[i].top       = y_pos;                // Y position.
        ButtonSizes[i].right = width;                // Button's width.
        ButtonSizes[i].bottom    = height;               // Button's height.
        y_pos += height + 4;
 
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonSizes[%d] = ( %d, %d, %d, %d )"), 
            i, ButtonSizes[i].left, ButtonSizes[i].top, ButtonSizes[i].right, ButtonSizes[i].bottom );
    }
 
    //==========================================================================
    // Create the "Buttons"
    //==========================================================================
    i = 0;
    j = 0;
 
    //--------------------------------------------------------------------------
    // Make any other necessary adjustments here.
    //--------------------------------------------------------------------------
    int count = 7;
 
    if ( !UninstallAvailable ) {
        count--;                    // No uninstall button.
    }
    if ( InstallProduct ) {
        count--;                    // No Website button.
    }
    button_index = 0;
 
    strcpy( next_button_name, ButtonImages[button_index] );
    strcpy( focused_button_name, FocusedButtonImages[button_index] );
 
    button_size = ButtonSizes;
    i = j = button_index;
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("count = %d."), count );
    Msg( __LINE__, TEXT(__FILE__), TEXT("button_index = %d."), button_index );
    Msg( __LINE__, TEXT(__FILE__), TEXT("next_button_name = %s."), next_button_name );
    Msg( __LINE__, TEXT(__FILE__), TEXT("focused_button_name = %s."), focused_button_name );
 
 
    //-------------------------------------------------------------------------
    // INSTALL or PLAY?
    //-------------------------------------------------------------------------
    if ( InstallProduct ) {
 
        //---------------------------------------------------------------------
        // (8) INSTALL button.
        //---------------------------------------------------------------------
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_OK, j, "Install" );
        ButtonList[i++] = new DrawButton( 
            IDD_OK, 
            button_size[j++], 
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:Install" ), 
#else
            AsciiString("Autorun:Install"), 
#endif
            TTButtonFontPtr );
 
    } else {
 
        //---------------------------------------------------------------------
        // (8) PLAY button.
        //---------------------------------------------------------------------
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_OK2, j, "Play" );
        ButtonList[i++] = new DrawButton( 
            IDD_OK2, 
            button_size[j++], 
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:Play" ),
#else
            AsciiString("Autorun:Play"), 
#endif
            TTButtonFontPtr );
/*
        //---------------------------------------------------------------------
        // (8) WorldBuilder button.
        //---------------------------------------------------------------------
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_OK2, j, "WorldBuilder" );
//      ButtonList[i--] = new DrawButton( 
        ButtonList[i++] = new DrawButton( 
            IDD_OK3, 
//          button_size[j--], 
            button_size[j++], 
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:Worldbuilder" ), 
#else
            AsciiString("Autorun:Worldbuilder"), 
#endif
            TTButtonFontPtr );
*/
        //---------------------------------------------------------------------
        // (8) Check for updates button.
        //---------------------------------------------------------------------
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_OK2, j, "Check For Updates" );
//      ButtonList[i--] = new DrawButton( 
        ButtonList[i++] = new DrawButton( 
            IDD_OK4, 
//          button_size[j--], 
            button_size[j++], 
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:CheckForUpdates" ),
#else
            AsciiString("Autorun:CheckForUpdates"), 
#endif
            TTButtonFontPtr );
    }
 
    //-------------------------------------------------------------------------
    // (7) EXPLORE CD
    //-------------------------------------------------------------------------
    Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_EXPLORE, j, "Explore" );
    ButtonList[i++] = new DrawButton (
        IDD_EXPLORE,
        button_size[j++],
        BUTTON_REG,
        BUTTON_SEL,
        BUTTON_SEL,
#ifdef LEAN_AND_MEAN
        Locale_GetString( "Autorun:ExploreCD" ),
#else
        AsciiString("Autorun:ExploreCD"),
#endif
        TTButtonFontPtr );
//  strcpy( next_button_name, ButtonImages[button_index] );
//  strcpy( focused_button_name, FocusedButtonImages[button_index--] );
//  strcpy( focused_button_name, FocusedButtonImages[button_index++] );
 
    if ( !InstallProduct ) {
        //-----------------------------------------------------------------------
        // (3) WebSite button.
        //-----------------------------------------------------------------------
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_OK, j, "Install" );
        ButtonList[i++] = new DrawButton( 
            IDD_INTERNET, 
            button_size[j++],
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:Website" ),
#else
            AsciiString("Autorun:Website"), 
#endif
            TTButtonFontPtr );
 
//      strcpy( next_button_name, ButtonImages[button_index] );
//      strcpy( focused_button_name, FocusedButtonImages[button_index--] );
//      strcpy( focused_button_name, FocusedButtonImages[button_index++] );
    }
 
    //--------------------------------------------------------------------------
    // (2) UNINSTALL?
    //--------------------------------------------------------------------------
    if ( UninstallAvailable && !InstallProduct ) {
        Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_UNINSTALL, j, "Uninstall" );
        ButtonList[i++] = new DrawButton( 
            IDD_UNINSTALL, 
            button_size[j++],
            BUTTON_REG, 
            BUTTON_SEL, 
            BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
            Locale_GetString( "Autorun:Uninstall" ),
#else
            AsciiString("Autorun:Uninstall"), 
#endif
            TTButtonFontPtr );
 
//      strcpy( next_button_name, ButtonImages[button_index] );
//      strcpy( focused_button_name, FocusedButtonImages[button_index--] );
//      strcpy( focused_button_name, FocusedButtonImages[button_index++] );
    }
 
    //--------------------------------------------------------------------------
    // (1) MOH movie
    //--------------------------------------------------------------------------
    Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_PREVIEWS, j, "Preview Movies");
    ButtonList[i++] = new DrawButton(
        IDD_PREVIEWS,
        button_size[j++],
        BUTTON_REG,
        BUTTON_SEL,
        BUTTON_SEL,
#ifdef LEAN_AND_MEAN
    Locale_GetString( "Autorun:Previews" ),
#else
        AsciiString("Autorun:Previews"),
#endif
        TTButtonFontPtr );
 
    //--------------------------------------------------------------------------
    // (1) Help file
    //--------------------------------------------------------------------------
    Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_HELP, j, "Help file");
    ButtonList[i++] = new DrawButton(
        IDD_HELP,
        button_size[j++],
        BUTTON_REG,
        BUTTON_SEL,
        BUTTON_SEL,
#ifdef LEAN_AND_MEAN
    Locale_GetString( "Autorun:Help" ),
#else
        AsciiString("Autorun:Help"),
#endif
        TTButtonFontPtr );
 
    //--------------------------------------------------------------------------
    // (1) CANCEL?
    //--------------------------------------------------------------------------
    Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=%d, String=%s."), i, IDD_CANCEL, j, "Cancel" );
    ButtonList[i++] = new DrawButton( 
        IDD_CANCEL, 
        button_size[j++], 
        BUTTON_REG, 
        BUTTON_SEL, 
        BUTTON_SEL, 
#ifdef LEAN_AND_MEAN
        Locale_GetString( "Autorun:Cancel" ),
#else
        AsciiString("Autorun:Cancel"), 
#endif
        TTButtonFontPtr );
 
//  strcpy( next_button_name, ButtonImages[button_index] );
//  strcpy( focused_button_name, FocusedButtonImages[button_index--] );
//  strcpy( focused_button_name, FocusedButtonImages[button_index++] );
 
    //-------------------------------------------------------------------------
    // Set the top button to have the focus.
    //-------------------------------------------------------------------------
    if ( ButtonList[0]) {
        Msg( __LINE__, TEXT(__FILE__), TEXT("Button with starting Focus = %d"), i );
        ButtonList[0]->Set_State( DrawButton::FOCUS_STATE );
    }
 
#if( _DEBUG )
    Msg( __LINE__, TEXT(__FILE__), TEXT("----------------------------------------------------------------------------------"));
    for( i=0; i<NUM_BUTTONS; i++ ) {
        if ( ButtonList[i]) {
            Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonList[%d]: Id=%d, ButtonSizes=[%d,%d,%d,%d]."), 
                i, 
                ButtonList[i]->Return_Id(),
                ButtonList[i]->Return_X_Pos(),
                ButtonList[i]->Return_Y_Pos(),                
                ButtonList[i]->Return_Width(),
                ButtonList[i]->Return_Height());
        }
    }
#endif
}
 
 
//*****************************************************************************
// WndProc -- Get Main Window's Stored Word.                                            
//                                                                         
// INPUT:         HWND hWnd.                                                                
//                      Window *pWindow                                                     
//                                                                         
// OUTPUT:        none.                                                     
//                                                                         
// WARNINGS:      none.                                                    
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
LRESULT CALLBACK  Wnd_Proc ( HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam )
{
    //--------------------------------------------------------------------------
    // If the GlobalMainWindow Ptr is not initialized, do it when the MW-CREATE
    // msg is called.  Then we use the GlobalMainWindow's WindowProc to
    // process all the individual msgs sent.
    //--------------------------------------------------------------------------
    if ( GlobalMainWindow == NULL ) {
        if ( iMessage == WM_CREATE ) {
 
                LPCREATESTRUCT lpcs;
 
                lpcs = (LPCREATESTRUCT) lParam;
                GlobalMainWindow = (MainWindow *) lpcs->lpCreateParams;
 
                //-----------------------------------------------------------------
                // Now let the object perform whatever initialization it needs
                // for WM_CREATE in its own WndProc.
                //-----------------------------------------------------------------
                return GlobalMainWindow->Window_Proc( hWnd, iMessage, wParam, lParam );
 
        } else {
            return DefWindowProc( hWnd, iMessage, wParam, lParam );
        }
 
    } else {
        return GlobalMainWindow->Window_Proc( hWnd, iMessage, wParam, lParam );
    }
}
 
//*****************************************************************************
// DIALOG_BOX_PROC -- Handles dlg messages                     
//                                                                         
// INPUT: standard windows dialog command parameters                       
//                                                                         
// OUTPUT: unused                                                          
//                                                                         
// WARNINGS: none                                                          
//                                                                         
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
BOOL CALLBACK  Dialog_Box_Proc( HWND window_handle, UINT message, WPARAM w_param, LPARAM l_param )
{
    int     i = 0, j = 0;
    int     nResult = 0;
//  int     space_between = 5;
    int     prevDCStretchMode;
    int     prevMemDCStretchMode;
    int     prevButtonDCStretchMode;
    int     prevLicenseDCStretchMode;
    int     result  = 0;
    char    buffer1[ 50 ];
//  char    buffer2[ 50 ];
 
    HDC             hDC, memDC, buttonDC, licenseDC;
    BITMAP          bm, fm, lm;
//  LOGPALETTE    * plgpl = NULL;
    PAINTSTRUCT     ps;
    static int      bits_pixel = 0;
    static int      idCtl = 0;
    static int      mouse_x, mouse_y;
 
    static char     szBitmap[_MAX_PATH];
    static char     szLicense[ _MAX_PATH ];
    static char     szButtonBitmap[_MAX_PATH];
 
    static wchar_t  szString1[ 500 ];
    static wchar_t  szString2[ 500 ];
    static wchar_t  szWholeString[ 1000 ];
//  static wchar_t  szWSMsg1[ _MAX_PATH ];
 
#ifdef LEAN_AND_MEAN
 
#else
    static UnicodeString   wsMsg1;
#endif
 
    static wchar_t  szWSMsg2[ _MAX_PATH ];
    static wchar_t  szWholeWSMsg[ 1000 ];
//  static wchar_t  szInstallWarningMsg[ _MAX_PATH ];
 
    static HBITMAP      hBitmap             = 0;
    static HBITMAP      oldBitmap           = 0;
//  static HBITMAP      oldButtonBitmap     = 0;
    static HBITMAP      oldLicenseBitmap    = 0;
    static HBITMAP      hButtonBitmap       = 0;
    static HBITMAP      hFlicker[NUM_FLICKER_FRAMES];
    static HBITMAP      hLicenseBitmap; 
 
    static POINT        point;
    static HBRUSH       hStaticBrush        = 0;
    static HPALETTE     hpal                = 0;
    static HPALETTE     hpalold             = 0;
    static BOOL         FirstTime           = TRUE;
//  static BOOL         Flicker             = TRUE;
    static BOOL         Flicker             = FALSE;
    static int          FlickerIndex        = 0;
    static BOOL         PaintOnlyFlicker    = TRUE;
    static BOOL         PaintBackground     = TRUE;
    static UINT         timer_id            = 0;
    static RECT         rect;                                       // Desktop Window ( used once ).
    static RECT         tray_rect;                                  // Desktop Window w/o Tray size.
    static RECT         paint_rect;                                 // Size that needs to be repainted.
    static RECT         dlg_rect;                                   // Dialog client window size.
    static RECT         bitmap_rect;                                // Background bitmap size.
    static RECT         flicker_rect;                               // Flicker bitmap size.
    static RECT         buttons_rect;                               // Area where buttons are.
    static RECT         license_rect;                               // Area where buttons are.
    static RECT         BackgroundRect[ ( NUM_BUTTONS * 3 ) + 3 ];   // Background areas outside button area.
 
#if(USE_MOUSE_MOVES)
    static int CurrentButton = 0;
    static int LastButton = 0;
    static int PrevButton = 0;
#endif
 
    #if(0)
    {
        //-------------------------------------------------------------------------------
        // Used for debugging -- lining up objects using the mouse coordinates.
        //-------------------------------------------------------------------------------
        int   i = 0;
        HDC   hdc = GetDC( window_handle );
        char  string[10];
        POINT pPoint;
 
        GetCursorPos( &pPoint );
        ScreenToClient( window_handle, &pPoint );
        sprintf( string, "%d, %d", pPoint.x, pPoint.y );
        TextOut( hdc, 10, 50, string, 8 );
        ReleaseDC( window_handle, hdc );
    }
    #endif
 
 
    //-----------------------------------------------------------------------------------
    // Process Dialogs messages.
    //-----------------------------------------------------------------------------------
    switch( message ) {
 
        case WM_INITDIALOG:
            {
                //-----------------------------------------------------------------------
                // Set dialog's caption.
                //-----------------------------------------------------------------------
 
#ifdef LEAN_AND_MEAN
 
                Locale_GetString( "Autorun:Title", szWideBuffer );
                memset( szWideBuffer2, '\0', _MAX_PATH );
                swprintf( szWideBuffer2, szWideBuffer, szProductName );
                swprintf( szWideBuffer2, szWideBuffer, szFullProductName );
 
#else
 
                wideBuffer = TheGameText->fetch("Autorun:Title");
                wideBuffer2.format(wideBuffer, fullProductName.str());
                WideCharToMultiByte( CodePage, 0, wideBuffer2.str(), wideBuffer2.getLength()+1, szBuffer, _MAX_PATH, NULL, NULL );
 
#endif
 
 
                SetWindowText( window_handle, szBuffer );
 
                //-----------------------------------------------------------------------
                // Set Icon.
                //-----------------------------------------------------------------------
                SendMessage( window_handle, WM_SETICON, ICON_SMALL, (long)LoadIcon( Main::hInstance, MAKEINTRESOURCE(1)));
 
            #if(BACKGROUND_BITMAP)
 
                //-----------------------------------------------------------------------
                // Get the DeskTop's size and this dialogs size (in pixels).
                //-----------------------------------------------------------------------
                GetClientRect( GetDesktopWindow(), &rect );
                SystemParametersInfo( SPI_GETWORKAREA, 0, &tray_rect, 0 );

//                  b640X480 = TRUE;
//              } else if( rect.right <= 800 ) {
                    b800X600 = TRUE;
//              }
 
                //=======================================================================
                // Create Fonts.
                //=======================================================================
                HDC hdc = GetDC( window_handle );
 
                FontManager = new FontManagerClass( hdc );
                assert( FontManager != NULL );
                ReleaseDC( window_handle, hdc );
 
                //=======================================================================
                // Load messages for bottom of screen.
                //=======================================================================
//              memset( szString1,      '\0', MAX_PATH );
//              memset( szString2,      '\0', MAX_PATH );
//              memset( szWholeString,  '\0', 1000 );
 
//              Locale_GetString( EA_LICENSE_MSG1, szString1 );
//              Locale_GetString( EA_LICENSE_MSG2, szString2 );
//              swprintf( szWholeString, L"%s %s", szString1, szString2 );
 
//              memset( szWSMsg1,       '\0', _MAX_PATH );
                memset( szWSMsg2,       '\0', _MAX_PATH );
                memset( szWholeWSMsg,   '\0', 1000 ); 
 
//              Locale_GetString( WESTWOOD_COM_MSG, szWSMsg1 );
//              wsMsg1 = TheGameText->fetch("Autorun:WestwoodComMsg");
 
//              PlugInProductName( szWSMsg1, (wchar_t *)(fullProductName.str()) );
//              PlugInProductName( (wchar_t *)(wsMsg1.str()), (wchar_t *)(fullProductName.str()) );
//              wsMsg1 = Fix_Single_Ampersands ( wsMsg1, false );
//              swprintf( szWholeWSMsg, L"%s", wsMsg1.str() );
 
//              memset( szInstallWarningMsg, '\0', _MAX_PATH );
                
//              Locale_GetString( IDS_INSTALL_WARNING_MSG, szWideBuffer );
//              wideBuffer = TheGameText->fetch("Autorun:InstallWarningMsg");
 
//              swprintf( szInstallWarningMsg, wideBuffer.str(), fullProductName.str() );
 
                //=======================================================================
                // Load the correct background & animation bitmap.
                //=======================================================================
                memset( buffer1, '\0', sizeof( buffer1 ));
 
                if( b640X480 ) {
 
                    strcpy( szBitmap, _TEXT( "Background2" ));
 
                    if ( LANG_FRE == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_FRENCH2" ));
                    } else if ( LANG_GER == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_GERMAN2" ));
                    } else {
                        strcpy( szLicense, _TEXT( "License_USA2" ));
                    }
                    license_rect.left   = 186;
                    license_rect.top    = 414;
 
                } else if( b800X600 ) {
 
                    strcpy( szBitmap, _TEXT( "BacKground" ));
 
                    if ( LANG_FRE == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_FRENCH2" ));
                    } else if ( LANG_GER == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_GERMAN2" ));
                    } else {
                        strcpy( szLicense, _TEXT( "License_USA2" ));
                    }
                    license_rect.left   = 186;
                    license_rect.top    = 414;
 
                } else {
 
                    strcpy( szBitmap, _TEXT( "Background" ));
                    strcpy( buffer1, "FLICKER" );
 
                    if ( LANG_FRE == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_FRENCH" ));
                    } else if ( LANG_GER == LanguageID ) {
                        strcpy( szLicense, _TEXT( "License_GERMAN" ));
                    } else {
                        strcpy( szLicense, _TEXT( "License_USA" ));
                    }
                    license_rect.left   = 238;
                    license_rect.top    = 580;
                }
 
                //=======================================================================
                // Load flicker bitmap.
                //=======================================================================
                for( i = 0; i < NUM_FLICKER_FRAMES; i++ ) {
                    hFlicker[i] = 0;
//                  sprintf( buffer2, "%s%02d", buffer1, i );
//                  hFlicker[i] = LoadResourceBitmap( Main::hModule, buffer2, &hpal );
                    hFlicker[i] = LoadResourceBitmap( Main::hModule, buffer1, &hpal );
                }
 
                //-----------------------------------------------------------------------
                // Get the flicker bitmap's dimensions.
                //-----------------------------------------------------------------------
                result = 712;
 
                for( i = 0; i < NUM_FLICKER_POSITIONS; i++ ) {
                    if( i == 8 ) {
                        FlickerPositions[i][0] = result - 33;
                    } else if( i == 9 ) {
                        FlickerPositions[i][0] = result - 35;
                    } else if ( i > 8 ) {
                        FlickerPositions[i][0] = result - 28;
                    } else {
                        FlickerPositions[i][0] = result - 31;
                    }
                    FlickerPositions[i][1] = 560;
                    result = FlickerPositions[i][0];
                }
 
                if ( hFlicker[0] ) {
                    GetObject( hFlicker[0], sizeof( BITMAP ), (LPTSTR)&fm );
                    flicker_rect.left   = FlickerPositions[0][0];
                    flicker_rect.top    = FlickerPositions[0][1];
                    flicker_rect.right  = flicker_rect.left + fm.bmWidth;
                    flicker_rect.bottom = flicker_rect.top  + fm.bmHeight;
                }
 
                //-----------------------------------------------------------------------
                // Get the bitmap's dimensions.
                //-----------------------------------------------------------------------
                hLicenseBitmap  = LoadResourceBitmap( Main::hModule, szLicense, &hpal );
                if ( hLicenseBitmap ) {
                    GetObject( hLicenseBitmap, sizeof( BITMAP ), (LPTSTR)&lm );
                    license_rect.right  = license_rect.left + lm.bmWidth;
                    license_rect.bottom = license_rect.top  + lm.bmHeight;
                }
 
                //=======================================================================
                // Load background bitmap.
                //=======================================================================
                hBitmap  = LoadResourceBitmap( Main::hModule, szBitmap, &hpal );
                if ( hBitmap ) {
                    GetObject( hBitmap, sizeof( BITMAP ), (LPTSTR)&bm );
                }
 
                //-----------------------------------------------------------------------
                // Set the x, y, width, height of the Dialog and bitmaps dimensions.
                //-----------------------------------------------------------------------
                bitmap_rect.left    = dlg_rect.left     = 0;
                bitmap_rect.top     = dlg_rect.top      = 0; 
                bitmap_rect.right   = dlg_rect.right    = bm.bmWidth;   
                bitmap_rect.bottom  = dlg_rect.bottom   = bm.bmHeight;
  
                //-----------------------------------------------------------------------
                // Set the x, y, width, height of the Dialog and bitmaps dimensions.
                //-----------------------------------------------------------------------
                dlg_rect.left   = 0;
                dlg_rect.top    = 0; 
 
                if( b640X480 ) {
                    dlg_rect.right      = rect.right;   
                    dlg_rect.bottom     = tray_rect.bottom;                                         // desktop smaller than image
                } else if( b800X600 ) {
                    if(true){
                        dlg_rect.right      = bm.bmWidth + 6;   
                        dlg_rect.bottom     = bm.bmHeight + GetSystemMetrics( SM_CYCAPTION ) + 6;       // desktop larger than image
                    } else {
                        dlg_rect.right      = 640;//bm.bmWidth + 6; 
                        dlg_rect.bottom     = 480; //bm.bmHeight + GetSystemMetrics( SM_CYCAPTION ) + 6;        // desktop larger than image
                    }
                } else {
                    dlg_rect.right      = bm.bmWidth + 6;   
                    dlg_rect.bottom     = bm.bmHeight + GetSystemMetrics( SM_CYCAPTION ) + 6;       // desktop larger than image
                }
 
                //=======================================================================
                // Recreate Buttons based on Registry.
                //=======================================================================
                GlobalMainWindow->Create_Buttons( window_handle, &dlg_rect );
 
                //=======================================================================
                // Set Main Rectangle Areas around all the Buttons.
                //=======================================================================
 
                //-----------------------------------------------------------------------
                // Who is the first button?
                //-----------------------------------------------------------------------
                i = 0;
                while ( i < NUM_BUTTONS ) {
                    if ( ButtonList[i] == NULL ) {
                        i++;
                    } else {
                        break;
                    }
                }
 
                if( i >= NUM_BUTTONS || i < 0 ) {
                    i = 0;
                }
 
                Msg( __LINE__, TEXT(__FILE__), TEXT("----------------------------- determining button area ---------------------------" ));
 
                buttons_rect.left   = ButtonSizes[i].left;                                                 
                buttons_rect.top    = ButtonSizes[i].top;                                                  
                buttons_rect.right  = ButtonSizes[i].left + ButtonSizes[i].right;                          
                buttons_rect.bottom = ButtonSizes[i].top  +  ButtonSizes[i].bottom;
 
//              Msg( __LINE__, TEXT(__FILE__), TEXT("buttons_rect = [%d,%d,%d,%d]"), buttons_rect.left, buttons_rect.top, buttons_rect.right, buttons_rect.bottom );
 
                for( j = 0; j < NUM_BUTTONS; j++ ) {
                    if ( ButtonList[j] != NULL ) {
                        buttons_rect.left   = __min( ButtonSizes[j].left                         , buttons_rect.left  ); 
                        buttons_rect.top    = __min( ButtonSizes[j].top                              , buttons_rect.top   );
                        buttons_rect.right  = __max( ButtonSizes[j].left + ButtonSizes[j].right       , buttons_rect.right  );                          
                        buttons_rect.bottom = __max( ButtonSizes[j].top  + ButtonSizes[j].bottom  , buttons_rect.bottom );
                    }
                }
 
                Msg( __LINE__, TEXT(__FILE__), TEXT("buttons_rect = [%d,%d,%d,%d]"), buttons_rect.left, buttons_rect.top, buttons_rect.right, buttons_rect.bottom );
                Msg( __LINE__, TEXT(__FILE__), TEXT("----------------------------- determining button area ---------------------------" ));
 
                //=======================================================================
                // Center the dialog on the desktop.
                //=======================================================================
                if ( !b640X480 ) {
                    MoveWindow( window_handle,
                        ( rect.right  - dlg_rect.right  )/2,
                        ( rect.bottom - dlg_rect.bottom )/2,
                        dlg_rect.right, 
                        dlg_rect.bottom, TRUE );
                } else {
                    MoveWindow( window_handle, 
                        0, 0,
                        dlg_rect.right, 
                        dlg_rect.bottom, TRUE );
                }
 
                //-----------------------------------------------------------------------
                // Get the new Client area.
                //-----------------------------------------------------------------------
                GetClientRect( window_handle, &dlg_rect );
 
                
                //=======================================================================================
                // JFS: 8/26/03 -- This was not getting cleared so if the button cnt were reduced...
                //=======================================================================================
                memset( BackgroundRect, 0, sizeof ( BackgroundRect ) );
 
                //=======================================================================
                // These are the areas of the Background to paint minus the Button Area.
                // This will prevent "flickering".
                //=======================================================================
                BackgroundRect[0].left      = dlg_rect.left;
                BackgroundRect[0].top       = dlg_rect.top;
                BackgroundRect[0].right     = dlg_rect.right;
                BackgroundRect[0].bottom    = buttons_rect.top;
 
                BackgroundRect[1].left      = dlg_rect.left;
                BackgroundRect[1].top       = buttons_rect.top;
                BackgroundRect[1].right     = buttons_rect.left;
                BackgroundRect[1].bottom    = dlg_rect.bottom;
 
                BackgroundRect[2].left      = buttons_rect.left;
                BackgroundRect[2].top       = buttons_rect.bottom;
                BackgroundRect[2].right     = buttons_rect.right;
                BackgroundRect[2].bottom    = dlg_rect.bottom;
 
                BackgroundRect[3].left      = buttons_rect.right;
                BackgroundRect[3].top       = buttons_rect.top;
                BackgroundRect[3].right     = dlg_rect.right;
                BackgroundRect[3].bottom    = dlg_rect.bottom;
 
                //=======================================================================
                // Find Areas that are in between, infront of, and behind each Buttons.
                //=======================================================================
                i = 0;
                j = 4;
 
                //-----------------------------------------------------------------------
                // Who is the first button?
                //-----------------------------------------------------------------------
                while ( i < NUM_BUTTONS ) {
                    if ( ButtonList[i] == NULL ) {
                        i++;
                    } else {
                        break;
                    }
                }
 
                if( i >= NUM_BUTTONS || i < 0 ) {
                    i = 0;
                }
 
                //-----------------------------------------------------------------------
                // For each button...
                //-----------------------------------------------------------------------
                for( int index = i; index < NUM_BUTTONS; index++ ) {
 
                    //-------------------------------------------------------------------
                    // Make areas between the buttons.
                    //-------------------------------------------------------------------
                    if ( ButtonList[index] != NULL && ButtonList[index+1] != NULL ) {
 
                        // Area between buttons.
                        BackgroundRect[j].top       = ButtonList[index]->Return_Y_Pos() + ButtonList[index]->Return_Height();
                        BackgroundRect[j].bottom    = ButtonList[index+1]->Return_Y_Pos() - BackgroundRect[j].top;
                        BackgroundRect[j].left      = BackgroundRect[1].right;
                        BackgroundRect[j].right     = BackgroundRect[3].left - BackgroundRect[1].left - 1;
                        j++;
                    }
 
                    //-------------------------------------------------------------------
                    // Now look for areas in front of and behind each button.
                    //-------------------------------------------------------------------
                    if ( ButtonList[index] != NULL ) {
 
                        // Area in front of buttons.
                        BackgroundRect[j].top       = ButtonList[index]->Return_Y_Pos();
                        BackgroundRect[j].bottom    = ButtonList[index]->Return_Height();
                        BackgroundRect[j].left      = BackgroundRect[1].right;
                        BackgroundRect[j].right     = ButtonList[index]->Return_X_Pos() - BackgroundRect[1].right;
                        j++;
 
                        // Area behind buttons.
                        BackgroundRect[j].top       = ButtonList[index]->Return_Y_Pos();
                        BackgroundRect[j].bottom    = ButtonList[index]->Return_Height();
                        BackgroundRect[j].left      = ButtonList[index]->Return_X_Pos() + ButtonList[index]->Return_Width();
                        BackgroundRect[j].right     = BackgroundRect[3].left - ( ButtonList[index]->Return_X_Pos() + ButtonList[index]->Return_Width());
                        j++;
                    }
                }
 
                #if(_DEBUG)
                    Msg( __LINE__, TEXT(__FILE__), TEXT("----------------------------- WM_INITDIALOG ---------------------------" ));
                    Msg( __LINE__, TEXT(__FILE__), TEXT("DeskTopWindowRect(w/o tray) = [%d,%d,%d,%d]"), tray_rect.left, tray_rect.top, tray_rect.right, tray_rect.bottom );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("DeskTopWindowRect   = [%d,%d,%d,%d]"), rect.left, rect.top, rect.right, rect.bottom );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("b640X480        = [%d]"), b640X480 );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("b800X600        = [%d]"), b800X600 );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("ClientRect      = [%d,%d,%d,%d]"), dlg_rect.left, dlg_rect.top, dlg_rect.right, dlg_rect.bottom );
                    
                    for( index = 0; index < ( NUM_BUTTONS * 3 ) + 3; index++ ) {
                        Msg( __LINE__, TEXT(__FILE__), TEXT("BackgroundRect[%d]  = [%d,%d,%d,%d]"), index, BackgroundRect[index].top, BackgroundRect[index].bottom, BackgroundRect[index].left, BackgroundRect[index].right );
                    }
                    
                    Msg( __LINE__, TEXT(__FILE__), TEXT("BitmapRect      = [%d,%d,%d,%d]"), bitmap_rect.left, bitmap_rect.top, bitmap_rect.right, bitmap_rect.bottom );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("FlickerRect     = [%d,%d,%d,%d]"), flicker_rect.left, flicker_rect.top, flicker_rect.right, flicker_rect.bottom );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("ButtonsRect     = [%d,%d,%d,%d]"), buttons_rect.left, buttons_rect.top, buttons_rect.right, buttons_rect.bottom );
                    Msg( __LINE__, TEXT(__FILE__), TEXT("-----------------------------------------------------------------------" ));
                #endif
 
            #else
 
                //-----------------------------------------------------------------------
                // Create Brush.
                //-----------------------------------------------------------------------
                hStaticBrush = CreateSolidBrush( RGB( 192, 192, 192 ));
 
            #endif
 
                //=======================================================================
                // Set dialog's timer!  1000 = 1 second.
                //=======================================================================
//              timer_id = SetTimer( window_handle, 1000, 250L, NULL );
                timer_id = SetTimer( window_handle, 1000, 500L, NULL );
            }
            return( TRUE );
 
        //-------------------------------------------------------------------------------
        // Try and set a custom cursor.
        //-------------------------------------------------------------------------------
//      case WM_SETCURSOR:
//          SetCursor(LoadCursor( Main::hInstance, MAKEINTRESOURCE(2))); 
//          break;
 
        //-------------------------------------------------------------------------------
        // Tell Window to Select Palette if we are not the Focused Window.
        // This is to avoid getting stuck in a loop of receiving this msg
        // when we are focused.
        //-------------------------------------------------------------------------------
        case WM_PALETTECHANGED:
            if (( HWND )w_param != window_handle ) {
                SendMessage( window_handle, WM_QUERYNEWPALETTE, w_param, l_param );
            }
            break;
 
        //-------------------------------------------------------------------------------
        // Set and Realize our palette, then repaint if necessary.
        // Note that SelectPalette here is passed a FALSE.  
        // This means reset palette as if we are in the foreground.
        //-------------------------------------------------------------------------------
        case WM_QUERYNEWPALETTE:
            hDC = GetDC( window_handle );
            hpalold = SelectPalette( hDC, hpal, FALSE );
            i = RealizePalette( hDC );
            if ( i != 0 ) {
                InvalidateRect( window_handle, &dlg_rect, TRUE );
            }
            SelectPalette( hDC, hpalold, TRUE );
            RealizePalette( hDC );
            ReleaseDC( window_handle, hDC );
            return i;
 
        //-------------------------------------------------------------------------------
        // Process Timer Messages.
        //-------------------------------------------------------------------------------
        case WM_TIMER:
            {
                if ( w_param == 1000 ) {
 
//                  if ( Flicker && hFlicker[FlickerIndex] ) {
                    if ( Flicker && hFlicker[0] ) {
 
                        FlickerIndex++;
//                      if ( FlickerIndex >= NUM_FLICKER_FRAMES ) {
                        if ( FlickerIndex >= NUM_FLICKER_POSITIONS ) {
                            FlickerIndex = 0;
                        }
 
                        InvalidateRect( window_handle, &flicker_rect, FALSE );
                        flicker_rect.left  = FlickerPositions[ FlickerIndex ][0];
                        InvalidateRect( window_handle, &flicker_rect, FALSE );
                        UpdateWindow( window_handle );
 
                        Msg( __LINE__, TEXT(__FILE__), TEXT("WM_TIMER: FlickerRect = [%d,%d,%d,%d]"), flicker_rect.left, flicker_rect.right, flicker_rect.top, flicker_rect.bottom );
                    }
                }
 
                //-----------------------------------------------------------------------
                // If game is running, the mutex will return!  Time to exit...
                // Note:  This number is unique for Tiberian Sun ONLY!!!
                //-----------------------------------------------------------------------
                if( WinVersion.Is_Win_XP() || WinVersion.Version() > 500 ) {
                    strcat( strcpy( szBuffer, "Global\\" ), GAME_MUTEX_OBJECT );
                } else {
                    strcpy( szBuffer, GAME_MUTEX_OBJECT );
                }
                GameAppMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, szBuffer );
 
                if ( GameAppMutex != NULL ) {
 
                    //---------------------------------------------------------
                    // Handle(s) are closed in the ProgEnd().
                    //---------------------------------------------------------
 
                    HWND ccwindow = FindWindow( szGameWindow, NULL );
                    if ( ccwindow ) {
                        if( IsIconic( ccwindow )){
                            ShowWindow( ccwindow, SW_RESTORE );
                        }
                        SetForegroundWindow( ccwindow );
 
                    } else {
 
                        ccwindow = FindWindow( szSetupWindow, NULL );
                        if ( ccwindow ) {
                            if( IsIconic( ccwindow )){
                                ShowWindow( ccwindow, SW_RESTORE );
                            }
                            SetForegroundWindow( ccwindow );
                        }
                    }
 
                    PostMessage( window_handle, WM_COMMAND, (WPARAM)MAKELONG( IDD_CANCEL, BN_CLICKED ), (LPARAM)GetDlgItem( window_handle, IDD_CANCEL ));
                }
            }
            return ( 0 );
 
        //===============================================================================
        // Dialog's main paint routine.
        //===============================================================================
        case WM_PAINT:
 
            //---------------------------------------------------------------------------
            // If there is an area to update, repaint it.
            //---------------------------------------------------------------------------
            if ( GetUpdateRect( window_handle, &paint_rect, FALSE )) {
 
//              Msg( __LINE__, TEXT(__FILE__), TEXT("---------------------- WM_PAINT ---------------------"), i );
//              Msg( __LINE__, TEXT(__FILE__), TEXT("Rectangle to update  = [%d,%d,%d,%d]"), paint_rect.left, paint_rect.top, paint_rect.right, paint_rect.bottom );
                
                //-----------------------------------------------------------------------
                // Get dialog's hDC.
                //-----------------------------------------------------------------------
                hDC = BeginPaint( window_handle, &ps );
 
                #if( BACKGROUND_BITMAP )
 
                    if ( hBitmap ) {
 
                        //---------------------------------------------------------------
                        // Create a compatible DC for the bitmap.
                        //---------------------------------------------------------------
                        memDC       = CreateCompatibleDC( hDC );
                        buttonDC    = CreateCompatibleDC( hDC );
                        licenseDC   = CreateCompatibleDC( hDC );
 
                        //---------------------------------------------------------------
                        // Set stretching mode for bitmaps.
                        //---------------------------------------------------------------
                        prevDCStretchMode           = SetStretchBltMode( hDC, STRETCH_DELETESCANS );
                        prevMemDCStretchMode        = SetStretchBltMode( memDC, STRETCH_DELETESCANS );
                        prevButtonDCStretchMode     = SetStretchBltMode( buttonDC,STRETCH_DELETESCANS );
                        prevLicenseDCStretchMode    = SetStretchBltMode( licenseDC,STRETCH_DELETESCANS );
 
                        //---------------------------------------------------------------
                        // Set the palette in each DC.
                        //---------------------------------------------------------------
                        hpalold = SelectPalette( hDC, hpal, FALSE );
                        RealizePalette( hDC );
                        SelectPalette( memDC, hpal, FALSE );
                        RealizePalette( memDC );
                        SelectPalette( buttonDC, hpal, FALSE );
                        RealizePalette( buttonDC );
                        SelectPalette( licenseDC, hpal, FALSE );
                        RealizePalette( licenseDC );
                        
                        //---------------------------------------------------------------
                        // If area to update is a button area, this will be drawn farther
                        // on. This is to prevent "flickering" by drawing the background 
                        // then the button image.
                        //---------------------------------------------------------------
                        for ( i = 0; i < NUM_BUTTONS; i++ ) {
 
                            if ( ButtonList[i] ) {
 
                                ButtonList[i]->Return_Area( &rect );
 
                                if ( paint_rect.left    == rect.left    && 
                                     paint_rect.top     == rect.top     && 
                                     paint_rect.right   == rect.right   && 
                                     paint_rect.bottom  == rect.bottom ) {
                    
                                    PaintBackground = FALSE;
//                                  Msg( __LINE__, TEXT(__FILE__), TEXT("Rectangle matches a button to update = [%d,%d,%d,%d]"), rect.left, rect.top, rect.right, rect.bottom );
                                    break;
                                }
                            }
                        }
 
                        //===============================================================
                        // Paint the background. 
                        //===============================================================
                        if ( PaintBackground ) {
 
                            //-----------------------------------------------------------
                            // Select & Draw the background bitmap.
                            //-----------------------------------------------------------
                            oldBitmap = ( HBITMAP )SelectObject( memDC, hBitmap );
 
                            //-----------------------------------------------------------
                            // Updates area around the button area.
                            //-----------------------------------------------------------
                        #if(1)
                            for( int i=0; i < ( NUM_BUTTONS * 3 ) + 3; i++ ) {
 
                                if( BackgroundRect[i].left  != 0 || BackgroundRect[i].top    != 0 || 
                                    BackgroundRect[i].right != 0 || BackgroundRect[i].bottom != 0 ) {
 
                                    result = StretchBlt( hDC, 
                                        BackgroundRect[i].left, 
                                        BackgroundRect[i].top, 
                                        BackgroundRect[i].right, 
                                        BackgroundRect[i].bottom,
                                        memDC, 
                                        BackgroundRect[i].left, 
                                        BackgroundRect[i].top, 
                                        BackgroundRect[i].right, 
                                        BackgroundRect[i].bottom, 
                                        SRCCOPY );
 
                                    if( result != 0 ) {
//                                      Msg( __LINE__, TEXT(__FILE__), TEXT("Paint this rect = [%d,%d,%d,%d]"), BackgroundRect[i].left, BackgroundRect[i].top, BackgroundRect[i].right, BackgroundRect[i].bottom );
                                    }
 
                                #if(0)
                                    HPEN    pen     = CreatePen( /*PS_DOT*/ PS_SOLID, 1, TEXT_COLOR );
                                    HGDIOBJ oldpen  = SelectObject( hDC, pen );
                                    SetBkMode( hDC, TRANSPARENT );
                    
                                    MoveToEx(   hDC, BackgroundRect[i].left+1,  BackgroundRect[i].top+1,    NULL );
                                    LineTo(     hDC, BackgroundRect[i].right-1, BackgroundRect[i].top+1 ); 
                                    LineTo(     hDC, BackgroundRect[i].right-1, BackgroundRect[i].bottom-1 );       
                                    LineTo(     hDC, BackgroundRect[i].left+1,  BackgroundRect[i].bottom-1 );       
                                    LineTo(     hDC, BackgroundRect[i].left+1,  BackgroundRect[i].top+1 );          
 
                                    SelectObject( hDC, oldpen );
                                    DeleteObject( pen );
                                #endif
                                }
                            }
/*
                            //-----------------------------------------------------------
                            // Select & Draw the background bitmap.
                            //-----------------------------------------------------------
                            oldLicenseBitmap = ( HBITMAP )SelectObject( licenseDC, hLicenseBitmap );
 
                            //-----------------------------------------------------------
                            // Updates area around the button area.
                            //-----------------------------------------------------------
                            result = StretchBlt( hDC, 
                                        license_rect.left, 
                                        license_rect.top, 
                                        license_rect.right, 
                                        license_rect.bottom,
                                        licenseDC, 
                                        0, 
                                        0, 
                                        license_rect.right, 
                                        license_rect.bottom, 
                                        SRCCOPY );
*/
                        #else
 
                            //-----------------------------------------------------------
                            // Blit whole background, in one shot.
                            //-----------------------------------------------------------
                            StretchBlt( hDC, dlg_rect.left, dlg_rect.top, dlg_rect.right, dlg_rect.bottom,
                                        memDC, bitmap_rect.left, bitmap_rect.top, bitmap_rect.right, bitmap_rect.bottom,
                                        SRCCOPY );
                        #endif
 
                            SelectObject( memDC, oldBitmap );
                            SelectObject( licenseDC, oldLicenseBitmap );
 
                        } else {
                            PaintBackground = TRUE;
                        }
 
                        //---------------------------------------------------------------
                        // Animation.
                        //---------------------------------------------------------------
//                      if ( Flicker && hFlicker[FlickerIndex] ) {
                        if ( Flicker && hFlicker[0] ) {
 
//                          oldBitmap = ( HBITMAP )SelectObject( memDC, hFlicker[FlickerIndex] );
                            oldBitmap = ( HBITMAP )SelectObject( memDC, hFlicker[0] );
 
                            StretchBlt( 
                                hDC, 
                                flicker_rect.left, 
                                flicker_rect.top, 
                                flicker_rect.right, 
                                flicker_rect.bottom,
                                memDC, 
                                0, 
                                0, 
                                flicker_rect.right, 
                                flicker_rect.bottom, 
                                SRCCOPY );
 
                            #if(0)
                                HPEN    pen     = CreatePen( /*PS_DOT*/ PS_SOLID, 1, TEXT_COLOR );
                                HGDIOBJ oldpen  = SelectObject( hDC, pen );
                                SetBkMode( hDC, TRANSPARENT );
                
                                MoveToEx(   hDC, flicker_rect.left+1,   flicker_rect.top+1, NULL );
                                LineTo(     hDC, flicker_rect.right-1,  flicker_rect.top+1 ); 
                                LineTo(     hDC, flicker_rect.right-1,  flicker_rect.bottom-1 );        
                                LineTo(     hDC, flicker_rect.left+1,   flicker_rect.bottom-1 );        
                                LineTo(     hDC, flicker_rect.left+1,   flicker_rect.top+1 );           
 
                                SelectObject( hDC, oldpen );
                                DeleteObject( pen );
                            #endif
 
                            SelectObject( memDC, oldBitmap );
 
//                          Msg( __LINE__, TEXT(__FILE__), TEXT("       Drawing Flicker [%d,%d,%d,%d]."), flicker_rect.left, flicker_rect.top, flicker_rect.right, flicker_rect.bottom );
                        }
 
                        //---------------------------------------------------------------
                        // Draw each button.
                        //---------------------------------------------------------------
                        for ( i = 0; i < NUM_BUTTONS; i++ ) {
 
                            if ( ButtonList[i] ) {
 
                                Rect rect;
 
                                //-------------------------------------------------------
                                // Uses Bitmaps or DrawText???
                                //-------------------------------------------------------
                                if ( ButtonList[i]->Draw_Bitmaps()) {
 
                                    RECT src_rect, dst_rect;
 
                                    strcpy( szButtonBitmap, ButtonList[i]->Return_Bitmap( ));
                                    hButtonBitmap = LoadResourceBitmap( Main::hInstance, szButtonBitmap, &hpal, TRUE );
                                    if ( hButtonBitmap ) {
 
                                        GetObject( hButtonBitmap, sizeof( BITMAP ), (LPTSTR)&bm );
 
                                        dst_rect.left       = ButtonList[i]->Return_X_Pos();
                                        dst_rect.top        = ButtonList[i]->Return_Y_Pos();
                                        dst_rect.right      = ButtonList[i]->Return_Stretched_Width();
                                        dst_rect.bottom     = ButtonList[i]->Return_Stretched_Height();
                                        src_rect.left       = 0;
                                        src_rect.top        = 0;
                                        src_rect.right      = bm.bmWidth;
                                        src_rect.bottom     = bm.bmHeight;
 
                                        //-----------------------------------------------
                                        // Draw the button's bitmap background.
                                        //-----------------------------------------------
                                        oldBitmap = ( HBITMAP ) SelectObject( buttonDC, hButtonBitmap );
                                        StretchBlt( 
                                                    hDC, 
                                                    dst_rect.left,          
                                                    dst_rect.top,           
                                                    dst_rect.right,         
                                                    dst_rect.bottom,        
                                                    buttonDC, 
                                                    src_rect.left,          
                                                    src_rect.top,           
                                                    src_rect.right,         
                                                    src_rect.bottom,        
                                                    SRCCOPY );
 
                                        SelectObject( buttonDC, oldBitmap );
                                        DeleteObject( hButtonBitmap );
                                        hButtonBitmap = 0;
                                    }
 
                                } // END OF DRAW BITMAPS
 
#if(0)
                                TTFontClass *fontptr = ButtonList[i]->Return_Font_Ptr();
                                if ( fontptr ) {
 
                                    RECT outline_rect;
 
                                    ButtonList[i]->Return_Area( &outline_rect );
                                    ButtonList[i]->Return_Text_Area( &rect );
 
                                    /*
                                    ** This function was combining the pixel color with the background,
                                    ** so it never looked correct.
                                    */
//                                  SetTextColor( hDC, RGB( 0, 240, 0 ));
//                                  DrawFocusRect(  hDC, &dst_rect );
                                            
                                    if ( ButtonList[i]->Get_State() == DrawButton::PRESSED_STATE ) {
                                        fontptr->Print( 
                                            hDC, 
                                            ButtonList[i]->Return_Text(), 
                                            rect, 
                                            TEXT_PRESSED_COLOR, 
                                            TEXT_PRESSED_SHADOW_COLOR, 
                                            TPF_BUTTON,
                                            TPF_SHADOW );
 
                                    } else if ( ButtonList[i]->Get_State() == DrawButton::FOCUS_STATE ) {
                                        fontptr->Print( 
                                            hDC, 
                                            ButtonList[i]->Return_Text(), 
                                            rect, 
                                            TEXT_FOCUSED_COLOR, 
                                            TEXT_FOCUSED_SHADOW_COLOR, 
                                            TPF_BUTTON,
                                            TPF_SHADOW );
 
                                    } else {
                                        fontptr->Print( 
                                            hDC, 
                                            ButtonList[i]->Return_Text(), 
                                            rect, 
                                            TEXT_NORMAL_COLOR, 
                                            TEXT_NORMAL_SHADOW_COLOR, 
                                            TPF_BUTTON,
                                            TPF_SHADOW );
                                    }
                                
                                #if(0)
                                    HPEN    pen     = CreatePen( /*PS_DOT*/ PS_SOLID, 2, TEXT_COLOR );
                                    HGDIOBJ oldpen  = SelectObject( hDC, pen );
                                    SetBkMode( hDC, TRANSPARENT );
                                    
                                    MoveToEx( hDC,                  // handle to device context
                                        outline_rect.left,          // x-coordinate of new current position
                                        outline_rect.top,           // y-coordinate of new current position
                                        NULL );                     // pointer to old current position
                                    
                                    LineTo( hDC,                    // device context handle
                                        outline_rect.right,         // x-coordinate of line's ending point
                                        outline_rect.top );         // y-coordinate of line's ending point
                                    
                                    LineTo( hDC,                    // device context handle
                                        outline_rect.right,         // x-coordinate of line's ending point
                                        outline_rect.bottom );      // y-coordinate of line's ending point
                                    
                                    LineTo( hDC,                    // device context handle
                                        outline_rect.left,          // x-coordinate of line's ending point
                                        outline_rect.bottom );      // y-coordinate of line's ending point
                                    
                                    LineTo( hDC,                    // device context handle
                                        outline_rect.left,          // x-coordinate of line's ending point
                                        outline_rect.top );         // y-coordinate of line's ending point
                                    
                                    SelectObject( hDC, oldpen );
                                    DeleteObject( pen );
                                #endif
                                }
#else
                                ButtonList[i]->Draw_Text( hDC );
#endif
 
 
 
                            } // end of if button
 
                        }   // For each button...
 
                        //---------------------------------------------------------------
                        // Used in debugging -- draw rect around where buttons are.
                        //---------------------------------------------------------------
                        #if(0)
                            {
                                HPEN hPen1  = CreatePen( PS_SOLID, 1, RGB( 255, 255, 255 ));
                                if (hPen1) {
 
                                    for ( int i = 0; i < NUM_BUTTONS; i++ ) {
                                        if ( ButtonList[i] ) {
 
                                            HGDIOBJ oldpen = SelectObject(  hDC, hPen1 );
 
                                            MoveToEx( hDC, 
                                                ButtonList[i]->Return_X_Pos()-1, 
                                                ButtonList[i]->Return_Y_Pos()-1, NULL );
                                            LineTo( hDC,   
                                                ButtonList[i]->Return_X_Pos() + ButtonList[i]->Return_Width() + 1, 
                                                ButtonList[i]->Return_Y_Pos()-1 );
                                            LineTo( hDC,   
                                                ButtonList[i]->Return_X_Pos() + ButtonList[i]->Return_Width()  + 1, 
                                                ButtonList[i]->Return_Y_Pos() + ButtonList[i]->Return_Height() + 1);
                                            LineTo( hDC,   
                                                ButtonList[i]->Return_X_Pos()-1, 
                                                ButtonList[i]->Return_Y_Pos() + ButtonList[i]->Return_Height() + 1);
                                            LineTo( hDC,   
                                                ButtonList[i]->Return_X_Pos() - 1, 
                                                ButtonList[i]->Return_Y_Pos() - 1);
 
                                            SelectObject( hDC, oldpen );
                                        }
                                    }
                                }
                                DeleteObject( hPen1 );
                            }
                        #endif
 
                        //---------------------------------------------------------------
                        // Restore all default objects to DCs and delete.
                        //---------------------------------------------------------------
                        SetStretchBltMode( hDC, prevDCStretchMode );
                        SetStretchBltMode( memDC, prevMemDCStretchMode );
                        SetStretchBltMode( buttonDC, prevButtonDCStretchMode );
                        SetStretchBltMode( licenseDC, prevLicenseDCStretchMode );
                        
                        SelectPalette( hDC, hpalold, FALSE );
                        SelectPalette( memDC, hpalold, FALSE );
                        SelectPalette( buttonDC, hpalold, FALSE );
                        SelectPalette( licenseDC, hpalold, FALSE );
 
                        DeleteDC( memDC );
                        DeleteDC( buttonDC );
                        DeleteDC( licenseDC );
 
                    } // end of bitmaps
 
                    //===================================================================
                    // Draw a solid colored background.
                    //===================================================================
//                  GetClientRect( window_handle, (LPRECT) &dlg_rect );
//                  FillRect( hDC, &dlg_rect, (HBRUSH)( COLOR_WINDOW + 1 ));
 
                    //===================================================================
                    // Print text at bottom of screen.
                    //===================================================================
                    Rect        text_rect;
                    TTFontClass *fontptr = NULL;
 
                    if ( b640X480 ) {
                        fontptr = TTTextFontPtr640;
                    } else if ( b800X600 ) {
                        fontptr = TTTextFontPtr800;
                    } else {
                        fontptr = TTTextFontPtr;
                    }
 
                    if ( fontptr ) {
 
                        if ( b640X480 || b800X600 ) {
                            text_rect.X            =  10;
                            text_rect.Y            = 240;
                            text_rect.Width        = 140;      //498;
                            text_rect.Height  = 100;      //26;
                        } else {
                            text_rect.X            =  20;
                            text_rect.Y            = 340;
                            text_rect.Width        = 180;      //498;
                            text_rect.Height  = 120;      //26;
                        }
 
                        #if(0)
                            RECT one;
 
                            one.left    = text_rect.X;
                            one.top     = text_rect.Y;
                            one.right   = text_rect.X + text_rect.Width;
                            one.bottom  = text_rect.Y + text_rect.Height;
 
                            FrameRect( hDC, &one, (HBRUSH)( COLOR_WINDOW + 1 ));
//                          DrawFocusRect( hDC, &one );
                        #endif
 
                        //---------------------------------------------------------------
                        // WESTWOOD_COM Message at the top.
                        //---------------------------------------------------------------
/*
                        fontptr->Print( 
                            hDC, 
                            szWholeWSMsg,
                            text_rect, 
                            TEXT_COLOR, 
                            SHADOW_COLOR, 
                            TPF_CENTER_TEXT,
                            TPF_SHADOW );
*/
                    }
 
                    //---------------------------------------------------------------
                    // EA_COM Message at the bottom.
                    //---------------------------------------------------------------
                    #if(0)  // Moved this text to a bitmap.
                    fontptr = TTLicenseFontPtr;
                    if( fontptr ) {
 
                        if ( b640X480 || b800X600 ) {
                            text_rect.X            = 220;
                            text_rect.Y            = 400;
                            text_rect.Width        = 300;      //460;                       
                            text_rect.Height  =  48;      //26;
                        } else {
                            text_rect.X            = 250;
                            text_rect.Y            = 574;
                            text_rect.Width        = 420;      //460;                       
                            text_rect.Height  =  60;      //26;
                        }
 
                        #if(0)
                            RECT one;
 
                            one.left    = text_rect.X;
                            one.top     = text_rect.Y;
                            one.right   = text_rect.X + text_rect.Width;
                            one.bottom  = text_rect.Y + text_rect.Height;
 
                            FrameRect( hDC, &one, (HBRUSH)( COLOR_WINDOW + 1 ));
//                          DrawFocusRect( hDC, &one );
                        #endif
 
                        fontptr->Print( 
                            hDC, 
                            szWholeString,
                            text_rect, 
                            TEXT_COLOR, 
                            SHADOW_COLOR, 
                            TPF_CENTER_TEXT,
                            TPF_SHADOW );
                    }
                    #endif
 
                #else
                    //-------------------------------------------------------------------
                    // Select the Brush if it was successfully created.
                    //-------------------------------------------------------------------
                    if ( hStaticBrush ) {
                        HBRUSH  oldBrush   = (HBRUSH) SelectObject( hDC, hStaticBrush );
                        GetClientRect( window_handle, (LPRECT) &dlg_rect );
                        FillRect( hDC, &dlg_rect, hStaticBrush );
                        SelectObject( hDC, oldBrush );
                    }
                #endif
 
//              Msg( __LINE__, TEXT(__FILE__), TEXT("--------------------------------------------------------" ));
 
                EndPaint( window_handle, &ps );
 
                //-----------------------------------------------------------------------
                // Play DISK.WAV sound on CD.
                //-----------------------------------------------------------------------
                if ( FirstTime ) { 
                    if( UseSounds ) {
                        PlaySound( szWavs[ SongNumber ], NULL, SND_ASYNC | SND_RESOURCE );
                    }
                    FirstTime = FALSE;
                }
            } /* end of if */
            break;
 
        //-------------------------------------------------------------------------------
        // Background needs to be erased.  Note we are returning 1 here to "fake"
        // Windows into thinking we have already repainted the background with
        // our window brush.  This prevents "flickering" because of background
        // being repainted ( ususally white ) before WM_PAINT is processed.
        //-------------------------------------------------------------------------------
        #if(BACKGROUND_BITMAP)
        case WM_ERASEBKGND:
            InvalidateRect( window_handle, &dlg_rect, FALSE );
            return ( 1 );
        #endif
 
        //-------------------------------------------------------------------------------
        // Check which button was pressed.  If Explorer button was pressed,
        // call it now so we don't have to exit dialog.
        //-------------------------------------------------------------------------------
        case WM_COMMAND:
            {
                idCtl = LOWORD( w_param );
 
                unsigned int    result      = TRUE;
                bool            end_dialog  = false;
                int             cd_drive;
 
                szBuffer[1] = '\0';
                szBuffer[0] = tolower( szArgvPath[0] );
//              cd_drive    = (int)( szBuffer[0] - 'a' + 1 );
                cd_drive    = (int)( szBuffer[0] - 'a' );
 
            #if(BACKGROUND_BITMAP)
 
                switch ( idCtl ) {
 
                    //-------------------------------------------------------------------
                    // IDD_MOHAVI
                    //-------------------------------------------------------------------
                    case IDD_PREVIEWS:
                    {
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_PREVIEWS Selected." ));
                        // show the previews in succession.  each will wait for the previous to finish
                        // before playing.
                        unsigned int success;
 
                        char filepath[MAX_PATH];
                        _snprintf(filepath, MAX_PATH, "%s%s", szArgvPath, SC4AVI_FILENAME);
 
                        success = GlobalMainWindow->Run_OpenFile(cd_drive, filepath, true);
//                      if (success != 0) {
//                          success = GlobalMainWindow->Run_OpenFile(cd_drive, BFAVI_FILENAME, true);
//                      }
/*
                        if (success == 0) {
                            std::wstring wideBuffer = TheGameText->fetch("Autorun:CantRunAVIs");
                            std::wstring wideBuffer2 = TheGameText->fetch("Autorun:Error");
                            int length = wideBuffer.length();
                            WideCharToMultiByte( CodePage, 0, wideBuffer.c_str(), length+1, szBuffer, _MAX_PATH, NULL, NULL );
                            length = wideBuffer2.length();
                            WideCharToMultiByte( CodePage, 0, wideBuffer2.c_str(), length+1, szBuffer2, _MAX_PATH, NULL, NULL );
                            MessageBox( NULL, szBuffer, szBuffer2, MB_APPLMODAL | MB_OK );
                        }
*/
                    }
                    break;
 
                    case IDD_HELP:
                    {
                        std::wstring wFileName;
                        wFileName = Locale_GetString(HELP_FILENAME);
                        
                        std::string fname;
                        const wchar_t *tmp = wFileName.c_str();
                        char hack[2] = "a";
                        while (*tmp)
                        {
                            hack[0] = (char)( *tmp & 0xFF );
                            fname.append( hack );
                            tmp++;
                        }
 
                        char newdir[MAX_PATH];
                        char olddir[MAX_PATH];
                        char filepath[MAX_PATH];
 
                        GetCurrentDirectory(MAX_PATH, olddir);
 
                        _snprintf(newdir, MAX_PATH, "%ssupport", szArgvPath);
                        SetCurrentDirectory(newdir);
 
                        _snprintf(filepath, MAX_PATH, "%s%s", szArgvPath, fname.c_str());
 
                        unsigned int success;
                        success = GlobalMainWindow->Run_OpenFile(cd_drive, filepath, false);
 
                        SetCurrentDirectory(olddir);
 
/*
                        if (success == 0) {
                            std::wstring wideBuffer = TheGameText->fetch("Autorun:CantRunHelp");
                            std::wstring wideBuffer2 = TheGameText->fetch("Autorun:Error");
                            int length = wideBuffer.length();
                            WideCharToMultiByte( CodePage, 0, wideBuffer.c_str(), length+1, szBuffer, _MAX_PATH, NULL, NULL );
                            length = wideBuffer2.length();
                            WideCharToMultiByte( CodePage, 0, wideBuffer2.c_str(), length+1, szBuffer2, _MAX_PATH, NULL, NULL );
                            MessageBox( NULL, szBuffer, szBuffer2, MB_APPLMODAL | MB_OK );
                        }
*/
                    }
                    break;
 
                    //-------------------------------------------------------------------
                    // IDD_CANCEL
                    //-------------------------------------------------------------------
                    case IDD_CANCEL:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_CANCEL Selected." ));
                        end_dialog = true;
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_OK   -- Install
                    // IDD_OK2  -- Play
                    //-------------------------------------------------------------------
                    case IDD_OK:
                    case IDD_OK2:
                    case IDD_OK3:
                    case IDD_OK4:
 
//                      if( !Is_On_CD( PRODUCT_VOLUME_CD1 ) && IsEnglish ) {
                        if( !Is_On_CD( PRODUCT_VOLUME_CD1 )) {
 
                            //-----------------------------------------------------------
                            // If false is returned, then CANCEL was pressed.
                            //-----------------------------------------------------------
                            char volume_to_match[ MAX_PATH ];
 
                            Reformat_Volume_Name( PRODUCT_VOLUME_CD1, volume_to_match );
//                          result = Prompt_For_CD( window_handle, volume_to_match, IDS_INSERT_CDROM_WITH_VOLUME1, IDS_EXIT_MESSAGE2, &cd_drive );
                            result = Prompt_For_CD( window_handle, volume_to_match, "Autorun:InsertCDROMWithVolume1", "Autorun:ExitMessage2", &cd_drive );
                        }
 
                        if ( result ) {
                            if ( idCtl == IDD_OK ) {
                                Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_OK Selected." ));
                                result = GlobalMainWindow->Run_Setup( window_handle, &dlg_rect, cd_drive );
                            } else if ( idCtl == IDD_OK2 ) {
                                Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_OK2 Selected." ));
                                result = GlobalMainWindow->Run_Game( window_handle, &dlg_rect );
                            } else if (idCtl == IDD_OK3 ) {
                                Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_OK3 Selected, running WorldBuilder." ));
                                result = GlobalMainWindow->Run_WorldBuilder( window_handle, &dlg_rect );
                            } else if (idCtl == IDD_OK4 ) {
                                Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_OK4 Selected, running PatchGet." ));
                                result = GlobalMainWindow->Run_PatchGet( window_handle, &dlg_rect );
                            }
                        }
 
                        if ( result ) {
                            end_dialog = true;
                        }
                        break;
 
                #if(SHOW_MOH_DEMO)
                    //-------------------------------------------------------------------
                    // Launch demo from CD.
                    //-------------------------------------------------------------------
                    case IDD_VIEW_DEMO:
 
                        if( !Is_On_CD( PRODUCT_VOLUME_CD2 )) {
 
                            //-----------------------------------------------------------
                            // If false is returned, then CANCEL was pressed.
                            //-----------------------------------------------------------
                            char volume_to_match[ MAX_PATH ];
 
                            Reformat_Volume_Name( PRODUCT_VOLUME_CD2, volume_to_match );
//                          result = Prompt_For_CD( window_handle, volume_to_match, IDS_INSERT_CDROM_WITH_VOLUME2, IDS_EXIT_MESSAGE2, &cd_drive );
                            result = Prompt_For_CD( window_handle, volume_to_match, AsciiString("Autorun:InsertCDROMWithVolume2"), AsciiString("Autorun:ExitMessage2"), &cd_drive );
                        }
 
                        if ( result ) {
                            Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_VIEW_DEMO Selected." ));
                            result = GlobalMainWindow->Run_Demo( window_handle, &dlg_rect, cd_drive );
                        }
 
                        if ( result ) {
                            end_dialog = true;
                        }
 
                        break;
                #endif
 
                #if( SHOW_GAMESPY_BUTTON )
                    //-------------------------------------------------------------------
                    // Launch GameSpy Website.
                    //-------------------------------------------------------------------
                    case IDD_GAMESPY:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_GAMESPY Selected." ));
                        if( ViewHTML( GAMESPY_WEBSITE )) 
                        {
                            end_dialog = true;
                        } 
                        else 
                        {
                            Error_Message( Main::hInstance, AsciiString("Autorun:Generals"), AsciiString("Autorun:CantFindExplorer"), GAME_WEBSITE );
                        }
                        break;
                #endif
 
                    //-------------------------------------------------------------------
                    // Create a new online account.
                    //-------------------------------------------------------------------
                    case IDD_NEW_ACCOUNT:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_NEW_ACCOUNT Selected." ));
                        result = GlobalMainWindow->Run_New_Account( window_handle, &dlg_rect );
                        if ( result ) {
                            end_dialog = true;
                        }
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_REGISTER
                    //-------------------------------------------------------------------
                    case IDD_REGISTER:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_REGISTER Selected." ));
                        result = GlobalMainWindow->Run_Register( window_handle, &dlg_rect );
                        if ( result ) {
                            end_dialog = true;
                        }
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_INTERNET
                    //-------------------------------------------------------------------
                    case IDD_INTERNET:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_INTERNET Selected." ));
                        if( ViewHTML( GAME_WEBSITE )) {
                            end_dialog = true;
                        } 
                        else 
                        {
                            Error_Message( Main::hInstance, "Autorun:Generals", "Autorun:CantFindExplorer", GAME_WEBSITE );
                        }
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_UPDATE
                    //-------------------------------------------------------------------
                    case IDD_UPDATE:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_UPDATE Selected." ));
                        result = GlobalMainWindow->Run_Auto_Update( window_handle, &dlg_rect );
                        if ( result ) {
                            end_dialog = true;
                        }
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_EXPLORE
                    //-------------------------------------------------------------------
                    case IDD_EXPLORE:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_EXPLORE Selected." ));
                        GlobalMainWindow->Run_Explorer( "", window_handle, &dlg_rect );
                        end_dialog = true;
                        break;
 
                    //-------------------------------------------------------------------
                    // IDD_UNINSTALL
                    //-------------------------------------------------------------------
                    case IDD_UNINSTALL:
                        Msg( __LINE__, TEXT(__FILE__), TEXT("IDD_UNINSTALL Selected." ));
                        result = GlobalMainWindow->Run_Uninstall( window_handle, &dlg_rect );
 
                        //---------------------------------------------------------------
                        // MML 5/27/99:  I am exiting here because the we launch 
                        // Uninstll.exe which in turn launches Uninst.exe thus 
                        // ::Run_Install ends before Uninst.exe is done.
                        //---------------------------------------------------------------
#if 1
                        if ( result ) {
                            end_dialog = true;
                        }
#endif
                        break;
 
                    default:
                        break;
                }
 
                //-----------------------------------------------------------------------
                // Exit Autorun.
                //-----------------------------------------------------------------------
                if( end_dialog ) {
 
                    for ( i = 0; i < NUM_BUTTONS; i++ ) {
                        if ( ButtonList[i] ) {
                            delete( ButtonList[i] );
                            ButtonList[i] = NULL;
                        }
                    }
                    if ( hpal ) {
                        DeleteObject( hpal );
                    }
                    if ( hBitmap ) {
                        DeleteObject( hBitmap );
                    }
                    for( i = 0; i < NUM_FLICKER_FRAMES; i++ ) {
                        DeleteObject( hFlicker[i] );
                        hFlicker[i] = 0;
                    }
                    Stop_Sound_Playing();
                    KillTimer( window_handle, timer_id );
                    EndDialog( window_handle, idCtl );
                }
 
            #else
                if ( hStaticBrush ) {
                    DeleteObject( hStaticBrush );
                    hStaticBrush = 0;
                }
                EndDialog( window_handle, idCtl );
                KillTimer( window_handle, timer_id );
                KillTimer( window_handle, gem_timer_id );
            #endif
 
            }
            break;
 
        //-------------------------------------------------------------------------------
        // This message is the response to the Close Button in upper right corner.
        //-------------------------------------------------------------------------------
        case WM_SYSCOMMAND:
 
            if ( w_param == SC_CLOSE ) {
                #if(BACKGROUND_BITMAP)
 
                    for ( i = 0; i < NUM_BUTTONS; i++ ) {
                        if ( ButtonList[i] ) {
                            delete( ButtonList[i] );
                            ButtonList[i] = NULL;
                        }
                    }
                    if ( hpal ) {
                        DeleteObject( hpal );
                    }
                    if ( hBitmap ) {
                        DeleteObject( hBitmap );
                    }
                    for( i = 0; i < NUM_FLICKER_FRAMES; i++ ) {
                        DeleteObject( hFlicker[i] );
                        hFlicker[i] = 0;
                    }
 
                #else
                    if ( hStaticBrush ) {
                        DeleteObject( hStaticBrush );
                        hStaticBrush = 0;
                    }
                #endif
 
                //-----------------------------------------------------------------------
                // Stop the sound if still going.
                //-----------------------------------------------------------------------
                Stop_Sound_Playing();
 
                //-----------------------------------------------------------------------
                // Delete the arguments.
                //-----------------------------------------------------------------------
                if ( Args ) {
                    delete( Args );
                    Args = NULL;
                }
                KillTimer( window_handle, timer_id );
                EndDialog( window_handle, w_param );
            }
            break;
 
        //-------------------------------------------------------------------------------
        // WM_SYSCOLORCHANGE Message.
        // If your applications uses controls in Windows 95/NT, forward the 
        // WM_SYSCOLORCHANGE message to the controls. 
        //-------------------------------------------------------------------------------
        #if( !BACKGROUND_BITMAP )
        case WM_SYSCOLORCHANGE:
            if ( hStaticBrush ) {
                DeleteObject( hStaticBrush );
                hStaticBrush = CreateSolidBrush( GetSysColor( COLOR_WINDOW ));
            }
            break;
        #endif
 
        //-------------------------------------------------------------------------------
        //  WM_CTLCOLOR Message.
        //  wParam                  Handle to Child Window's device context
        //  LOWORD( lParam )        Child Window handle
        //  HIWORD( lParam )        Type of Window:     CTLCOLOR_MSGBOX, _EDIT, _LISTBOX, _BTN, _DLG, _SCROLLBAR, _STATIC
        //
        //  WM_CTLCOLORMSGBOX
        //  WM_CTLCOLOREDIT
        //  WM_CTLCOLORLISTBOX
        //  WM_CTLCOLORBTN
        //  WM_CTLCOLORDLG
        //  WM_CTLCOLORSCROLLBAR 
        //  WM_CTLCOLORSTATIC
        //  #define WM_CTLCOLOR                             0x0019
        //  #define GET_WM_CTLCOLOR_HDC (wp, lp, msg)       (HDC)(wp)
        //  #define GET_WM_CTLCOLOR_HWND(wp, lp, msg)       (HWND)(lp)
        //  #define GET_WM_CTLCOLOR_TYPE(wp, lp, msg)       (WORD)(msg - WM_CTLCOLORMSGBOX)
        //  #define GET_WM_CTLCOLOR_MSG (type)              (WORD)(WM_CTLCOLORMSGBOX+(type))
        //-------------------------------------------------------------------------------
        #if( !BACKGROUND_BITMAP )
        case WM_CTLCOLOR:
            if ( HIWORD( l_param ) == CTLCOLOR_STATIC ) {
 
                SetTextColor(( HDC )w_param, GetSysColor( COLOR_WINDOWTEXT ));
                SetBkColor( (HDC)wParam, GetSysColor( COLOR_WINDOW ));
//              SetBkColor(( HDC )w_param, RGB( 192, 192, 192 ));
 
                UnrealizeObject( hStaticBrush );                                    // reset the origin of the brush next time used.
                point.x = point.y = 0;                                              // create a point.
                ClientToScreen( window_handle, &point );                        // translate into screen coordinates.
                SetBrushOrgEx( (HDC)w_param, point.x, point.y, NULL );  // New Origin to use when next selected.
                return((LRESULT) hStaticBrush );
            }
        #endif
 
        //===============================================================================
        // Check where Left Mouse button was pressed.
        //===============================================================================
        #if(BACKGROUND_BITMAP)
        case WM_LBUTTONDOWN:
            {
                RECT rect;
 
                //----------------------------------------------------------------------
                // Get mouse coordinates.
                //----------------------------------------------------------------------
                mouse_x = LOWORD( l_param );
                mouse_y = HIWORD( l_param );
 
                //----------------------------------------------------------------------
                // For each button in the list...
                //----------------------------------------------------------------------
                for ( i = 0; i < NUM_BUTTONS; i++ ) {
 
                    //-------------------------------------------------------------------
                    // If mouse was clicked in one of the "buttons", then change
                    // that button's state to "pressed".
                    //-------------------------------------------------------------------
                    if ( ButtonList[i] && ButtonList[i]->Is_Mouse_In_Region( mouse_x, mouse_y )) {
 
                        if ( ButtonList[i]->Get_State() != DrawButton::PRESSED_STATE ) {
 
                            ButtonList[i]->Return_Area ( &rect );
                            ButtonList[i]->Set_State( DrawButton::PRESSED_STATE );
                            InvalidateRect( window_handle, &rect, FALSE );
 
                            Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONDOWN -- %s. rect = [%d,%d,%d,%d]."), 
                                ButtonList[i]->Return_Normal_Bitmap(), rect.left, rect.top, rect.right, rect.bottom );
 
                            UpdateWindow( window_handle );
                        }
                        break;
                    } 
                }
            }
            break;
        #endif
 
        //===============================================================================
        // Check where Left Mouse button was released.
        //===============================================================================
        #if(BACKGROUND_BITMAP)
        case WM_LBUTTONUP:
            {
                RECT rect;
                int focus_index = 0;
                int found_focus = -1;
 
                //-----------------------------------------------------------------------
                // Get mouse coordinates.
                //-----------------------------------------------------------------------
                mouse_x = LOWORD( l_param );
                mouse_y = HIWORD( l_param );
 
                //=======================================================================
                // focus_index = previous PRESSED/FOCUSED button.
                // found_focus = new PRESSED/FOCUSED button ( if different ).
                //=======================================================================
 
                //-----------------------------------------------------------------------
                // First find the button that is either focused or pressed.
                //-----------------------------------------------------------------------
                for ( i = 0; i < NUM_BUTTONS; i++ ) {
                    if ( ButtonList[i] ) {
 
                        //---------------------------------------------------------------
                        // Save index of button with focus.
                        //---------------------------------------------------------------
                        if( ButtonList[i]->Get_State() == DrawButton::FOCUS_STATE || 
                            ButtonList[i]->Get_State() == DrawButton::PRESSED_STATE ) {
                            focus_index = i;
                        }
                    }
                }
 
                //-----------------------------------------------------------------------
                // Then find the button that is to be focused or pressed.
                //-----------------------------------------------------------------------
                for ( i = 0; i < NUM_BUTTONS; i++ ) {
                    if ( ButtonList[i] && ButtonList[i]->Is_Mouse_In_Region( mouse_x, mouse_y )) {
                        found_focus = i;
                    }
                }
 
                //-----------------------------------------------------------------------
                // If new button is not found... 
                //-----------------------------------------------------------------------
                if ( found_focus == -1 ) {
 
                    //-------------------------------------------------------------------
                    // Make sure previously focused/pressed button is now is a 
                    // focused state and no action is taken.  This occurs when 
                    // mouse is clicked outside of any button areas.
                    //-------------------------------------------------------------------
                    if ( ButtonList[focus_index] && ( ButtonList[focus_index]->Get_State() != DrawButton::FOCUS_STATE )) {
 
                        ButtonList[focus_index]->Set_State( DrawButton::FOCUS_STATE );
                        ButtonList[focus_index]->Return_Area ( &rect );
                        InvalidateRect( window_handle, &rect, FALSE );
 
                        Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONUP -- %s[FOCUS_STATE] = [x=%d, y=%d, w=%d, h=%d]."), 
                            ButtonList[ focus_index ]->Return_Normal_Bitmap(),    rect.left, rect.top, rect.right, rect.bottom );
 
                        UpdateWindow( window_handle );
                    }
 
                } else {
 
                    //-------------------------------------------------------------------
                    // Buttons are one and the same.
                    //-------------------------------------------------------------------
                    if( focus_index == found_focus ) {
 
                        ButtonList[ found_focus ]->Set_State( DrawButton::FOCUS_STATE );
                        ButtonList[ found_focus ]->Return_Area ( &rect );
                        InvalidateRect( window_handle, &rect, FALSE );
 
                        Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONUP -- %s[FOCUS_STATE] = [x=%d, y=%d, w=%d, h=%d]."), 
                            ButtonList[ found_focus ]->Return_Normal_Bitmap(), rect.left, rect.top, rect.right, rect.bottom );
 
                        UpdateWindow( window_handle );
 
                    } else {
 
                        //---------------------------------------------------------------
                        // Make previously focused button, Normal...
                        //---------------------------------------------------------------
                        if ( ButtonList[ focus_index ] ) {
                    
                            ButtonList[ focus_index ]->Set_State( DrawButton::NORMAL_STATE );
                            ButtonList[ focus_index ]->Return_Area ( &rect );
                            InvalidateRect( window_handle, &rect, FALSE );
        
                            Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONUP -- %s[NORMAL_STATE] = [x=%d, y=%d, w=%d, h=%d]."), 
                                ButtonList[ focus_index ]->Return_Normal_Bitmap(),
                                rect.left, rect.top, rect.right, rect.bottom );
                        
                            UpdateWindow( window_handle );
                        }
 
                        //---------------------------------------------------------------
                        // ...and the new button now has focus.
                        //---------------------------------------------------------------
                        if ( ButtonList[ found_focus ] ) {
                    
                            ButtonList[ found_focus ]->Set_State( DrawButton::FOCUS_STATE );
                            ButtonList[ found_focus ]->Return_Area ( &rect );
                            InvalidateRect( window_handle, &rect, FALSE );
 
                            Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONUP -- %s[FOCUS_STATE] = [x=%d, y=%d, w=%d, h=%d]."), 
                                ButtonList[ found_focus ]->Return_Normal_Bitmap(), rect.left, rect.top, rect.right, rect.bottom );
 
                            UpdateWindow( window_handle );
                        }
                    }
                }
 
                //-----------------------------------------------------------------------
                // Repaint the Window now.
                //-----------------------------------------------------------------------
                nResult = UpdateWindow( window_handle );
 
                //-----------------------------------------------------------------------
                // Do the focus button's action.
                //-----------------------------------------------------------------------
                if ( found_focus >= 0 ) {
                    if (( ButtonList[found_focus] ) && 
                        ( ButtonList[found_focus]->Get_State() == DrawButton::FOCUS_STATE ) && 
                        ( ButtonList[found_focus]->Is_Mouse_In_Region( mouse_x, mouse_y ))) {
                            SendMessage( window_handle, WM_COMMAND, ButtonList[found_focus]->Return_Id(), 0L );
                            break;
                    }
                }
            }
            break;
        #endif
 
        //-------------------------------------------------------------------------------
        // Check Mouse moves over buttons.
        //-------------------------------------------------------------------------------
//#if(DISABLE_KEYBOARD)
        #if(BACKGROUND_BITMAP)
        case WM_MOUSEMOVE:
            {
                RECT rect;
                int j;
                int done = 0;
 
                //-----------------------------------------------------------------------
                // Get mouse coordinates.
                //-----------------------------------------------------------------------
                mouse_x = LOWORD( l_param );
                mouse_y = HIWORD( l_param );
 
            #if(USE_MOUSE_MOVES)
                //-----------------------------------------------------------------------
                // Reset most current button.                                            
                //-----------------------------------------------------------------------
                CurrentButton = 0;
            #endif
 
                //-----------------------------------------------------------------------
                // For each button in the list...                                        
                //-----------------------------------------------------------------------
                i = 0;
                while( i < NUM_BUTTONS && !done ) {
 
                    //-------------------------------------------------------------------
                    // For each button, check if mouse is in it's area.                 
                    //-------------------------------------------------------------------
                    if ( ButtonList[i] && ButtonList[i]->Is_Mouse_In_Region( mouse_x, mouse_y )) {
 
                        //---------------------------------------------------------------
                        // This is now the current button.                                 
                        //---------------------------------------------------------------
                        CurrentButton = ButtonList[i]->Return_Id();
 
                        if( CurrentButton != LastButton ) {
 
                            //-----------------------------------------------------------
                            // Make all other buttons, NORMAL.
                            //-----------------------------------------------------------
                            for ( j = 0; j < NUM_BUTTONS; j++ ) {
                                if ( ButtonList[j] ) {
                                    ButtonList[j]->Set_State( DrawButton::NORMAL_STATE );
//                                  Msg( __LINE__, TEXT(__FILE__), TEXT("WM_MOUSEMOVE -- %s[NORMAL_STATE]]."), ButtonList[j]->Return_Normal_Bitmap());
                                }
                            }
 
                            if ( w_param & MK_LBUTTON ) {
 
                                //--------------------------------------------------------
                                // Left Mouse button is pressed! Make it a pressed button!
                                //--------------------------------------------------------
                                if ( ButtonList[i] && ButtonList[i]->Get_State() != DrawButton::PRESSED_STATE ) {
                                    ButtonList[i]->Set_State( DrawButton::PRESSED_STATE );
//                                  Msg( __LINE__, TEXT(__FILE__), TEXT("WM_MOUSEMOVE -- %s[PRESSED_STATE]."), ButtonList[i]->Return_Normal_Bitmap());
                                }
 
                            } else {
        
                                //--------------------------------------------------------
                                // If this button is not already focused, give it the focus. 
                                //--------------------------------------------------------
                                if ( ButtonList[i] && ButtonList[i]->Get_State() != DrawButton::FOCUS_STATE ) {
                                    ButtonList[i]->Set_State( DrawButton::FOCUS_STATE );
//                                  Msg( __LINE__, TEXT(__FILE__), TEXT("WM_MOUSEMOVE -- %s[FOCUS_STATE]."), ButtonList[i]->Return_Normal_Bitmap());
                                }
                            }   // end of if
 
                            //-----------------------------------------------------------
                            // Get the area of the button, and post it for updating.
                            //-----------------------------------------------------------
                            for ( j = 0; j < NUM_BUTTONS; j++ ) {
                                if ( ButtonList[j] ) {
                                    ButtonList[j]->Return_Area ( &rect );
                                    InvalidateRect( window_handle, &rect, FALSE );
                                }
                            }
 
                            //-----------------------------------------------------------
                            // Repaint now!
                            //-----------------------------------------------------------
                            UpdateWindow( window_handle );
 
                            done = 1;
                        }
 
                    }   // end of if
                    i++;
 
                }   // end of for
 
 
            #if( USE_MOUSE_MOVES )
                //-----------------------------------------------------------------------
                // If a MouseMove was found to be in one of the buttons, then 
                // CurrentButton will have a value.
                //-----------------------------------------------------------------------
                if ( CurrentButton != 0 ) {
 
                    LastButton = CurrentButton;
 
                    //-------------------------------------------------------------------
                    // If we are still in the same button, don't make a sound!
                    //-------------------------------------------------------------------
                    if ( LastButton != PrevButton ) {
                        PrevButton = LastButton;
                        PlaySound( szButtonWav, Main::hModule, SND_ASYNC | SND_RESOURCE );
                    }
                }
            #endif
            }
            break;
 
        #endif  // Background_Bitmap flag
//#endif
 
        //-------------------------------------------------------------------------------
        // Repaint when focus is restored (does partial repaint), and when
        // mouse is double clicked on dialog ( full repaint ).
        //-------------------------------------------------------------------------------
        case WM_LBUTTONDBLCLK:
        case WM_SETFOCUS:
            InvalidateRect( window_handle, &dlg_rect, TRUE );
//          nResult = UpdateWindow( window_handle );
//          Msg( __LINE__, TEXT(__FILE__), TEXT("WM_LBUTTONDBLCLK -- dlg_rect = [x=%d, y=%d, w=%d, h=%d]."), 
//              dlg_rect.left, dlg_rect.top, dlg_rect.right, dlg_rect.bottom );
            break;
 
        #if(BACKGROUND_BITMAP)
        //-------------------------------------------------------------------------------
        // bit 30 of lParam - Specifies the previous key state. 
        // The value is 1 if the key is down before the message is sent, 
        // or it is 0 if the key is up.
        //-------------------------------------------------------------------------------
        case WM_KEYUP:
            {
//              int j = 0;
 
                switch( w_param ) {
 
                    case VK_ESCAPE:
                        SendMessage( window_handle, WM_SYSCOMMAND, SC_CLOSE, 0L );
                        break;
 
//#if(DISABLE_KEYBOARD)
                    case VK_RETURN:
                        //---------------------------------------------------------------
                        // If the Return/Enter key is pressed... find the focused
                        //  button and call its action.
                        //---------------------------------------------------------------
//                      result = ( l_param & 0x40000000 );
                        for ( i = 0; i < NUM_BUTTONS; i++ ) {
                            if ( ButtonList[i] && ButtonList[i]->Get_State() == DrawButton::FOCUS_STATE ) {
                                SendMessage( window_handle, WM_COMMAND, ButtonList[i]->Return_Id(), 0L );
                                break;
                            }
                        }
                        break;
//#endif
 
//#if(DISABLE_KEYBOARD)
                    case VK_TAB:
                    case VK_DOWN:
                        {
                            //-----------------------------------------------------------
                            // Find the button with focus and "tab" to the next button by finding 
                            // the next valid index.  If past last button, circle back to the top.
                            //-----------------------------------------------------------
                            int focused_button = 0;
                            int next_button = 0;
 
                            for ( i = 0; i < NUM_BUTTONS; i++ ) {
                                if ( ButtonList[i] && ButtonList[i]->Get_State() == DrawButton::FOCUS_STATE ) {
 
                                    focused_button = i;
                                    next_button = i+1;
 
                                    if ( next_button >= NUM_BUTTONS ) {
                                        next_button = 0;
                                    }
                                    while (( next_button < NUM_BUTTONS ) && !ButtonList[ next_button ] ) {
                                        next_button++;
                                    }
 
                                    if ( next_button >= NUM_BUTTONS ) {
                                        next_button = 0;
                                        while (( next_button < NUM_BUTTONS ) && !ButtonList[ next_button ] ) {
                                            next_button++;
                                        }
                                    }
                                    break;
                                }
                            }
 
                            //-----------------------------------------------------------
                            // Set the previous button to Normal status.
                            //-----------------------------------------------------------
                            if ( ButtonList[focused_button] && ( ButtonList[focused_button]->Get_State() != DrawButton::NORMAL_STATE )) {
 
                                ButtonList[focused_button]->Set_State( DrawButton::NORMAL_STATE );
                                ButtonList[focused_button]->Return_Area ( &rect );
                                InvalidateRect( window_handle, &rect, FALSE );
 
                                Msg( __LINE__, TEXT(__FILE__), TEXT("VK_DOWN/VK_TAB -- %s = [%s]."), ButtonList[focused_button]->Return_Normal_Bitmap(), "NORMAL_STATE" );
                            }
 
                            //-----------------------------------------------------------
                            // Set the new button to focus status.
                            //-----------------------------------------------------------
                            if ( ButtonList[next_button] && ( ButtonList[next_button]->Get_State() != DrawButton::FOCUS_STATE )) {
 
                                ButtonList[next_button]->Set_State( DrawButton::FOCUS_STATE );
                                ButtonList[next_button]->Return_Area ( &rect );
                                InvalidateRect( window_handle, &rect, FALSE );
                                PlaySound( szButtonWav, Main::hModule, SND_ASYNC | SND_RESOURCE );
 
                                Msg( __LINE__, TEXT(__FILE__), TEXT("VK_DOWN/VK_TAB -- %s = [%s]."), ButtonList[next_button]->Return_Normal_Bitmap(), "FOCUS_STATE" );
                            }
                        }
                        break;
 
                    case VK_UP:
                        {
                            //-----------------------------------------------------------
                            // Find the button with focus and "tab" to the next button by finding 
                            // the next valid index.  If past last button, circle back to the top.
                            //-----------------------------------------------------------
                            int focused_button = 0;
                            int next_button = 0;
 
                            for ( i = 0; i < NUM_BUTTONS; i++ ) {
                                if ( ButtonList[i] && ButtonList[i]->Get_State() == DrawButton::FOCUS_STATE ) {
 
                                    focused_button = i;
                                    next_button = i-1;
 
                                    if ( next_button < 0 ) {
                                        next_button = NUM_BUTTONS - 1;
                                    }
                                    while (( next_button > 0 ) && !ButtonList[ next_button ] ) {
                                        next_button--;
                                    }
 
                                    if ( !ButtonList[ next_button ]) {
                                        next_button = NUM_BUTTONS - 1;
                                    }
                                    while (( next_button >= 0 ) && !ButtonList[ next_button ] ) {
                                        next_button--;
                                    }
                                    break;
                                }
                            }
 
                            //-----------------------------------------------------------
                            // Set the previous button to Normal status.
                            //-----------------------------------------------------------
                            if ( ButtonList[focused_button] && ( ButtonList[focused_button]->Get_State() != DrawButton::NORMAL_STATE )) {
 
                                ButtonList[focused_button]->Set_State( DrawButton::NORMAL_STATE );
                                ButtonList[focused_button]->Return_Area ( &rect );
                                InvalidateRect( window_handle, &rect, FALSE );
 
                                Msg( __LINE__, TEXT(__FILE__), TEXT("VK_DOWN/VK_TAB -- %s = [%s]."), ButtonList[focused_button]->Return_Normal_Bitmap(), "NORMAL_STATE" );
                            }
 
                            //-----------------------------------------------------------
                            // Set the new button to focus status.
                            //-----------------------------------------------------------
                            if ( ButtonList[next_button] && ( ButtonList[next_button]->Get_State() != DrawButton::FOCUS_STATE )) {
 
                                ButtonList[next_button]->Set_State( DrawButton::FOCUS_STATE );
                                ButtonList[next_button]->Return_Area ( &rect );
                                InvalidateRect( window_handle, &rect, FALSE );
                                PlaySound( szButtonWav, Main::hModule, SND_ASYNC | SND_RESOURCE );
 
                                Msg( __LINE__, TEXT(__FILE__), TEXT("VK_DOWN/VK_TAB -- %s = [%s]."), ButtonList[next_button]->Return_Normal_Bitmap(), "FOCUS_STATE" );
                            }
                        }
                        break;
//#endif
 
                }   /* end of switch */
            }   /* end of case stmt */
 
            return ( 0 );
 
        #endif
    }
    return( FALSE );
}
 
//*****************************************************************************
// STOP_SOUND_PLAYING -- Stop the background sound.
//                                                                 
// INPUT:       none.
//                                                                 
// OUTPUT:      none.
//                                                                 
// WARNINGS:    Will stop any sound started by PlaySound.
//                                                                 
// HISTORY:                                                                
//   06/04/1999  MML : Created.                                            
//=============================================================================
 
void Stop_Sound_Playing ( void )
{
    PlaySound( NULL, NULL, SND_ASYNC | SND_FILENAME );
}
 
//*****************************************************************************
// OPTIONS -- Find any user options and set the correct flags      
//                                                                 
// INPUT:   int argc      =  no. of arguments to check               
//          BYTE *argv[]  =  ptr to actual command line parameters 
//                                                                 
// OUTPUT:                                                         
//                                                                 
// WARNINGS:                                                       
//                                                                 
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
BOOL Options( Command_Line_Arguments *Orgs )
{
    int     i;
    BOOL    result = TRUE;
    char    buffer[ MAX_ARGUMENT_LENGTH ];
 
    //-------------------------------------------------------------------------
    // Scan arguments for any options ( / or - followed by a letter)
    //-------------------------------------------------------------------------
    for ( i = 0; i < Orgs->Get_argc(); i++ ) {
 
        //---------------------------------------------------------------------
        // Get the next item in the list.
        //---------------------------------------------------------------------
        memset( buffer, '\0', sizeof( buffer ));
        strcpy( buffer, Orgs->Get_argv(i));
 
        Msg( __LINE__, TEXT(__FILE__), TEXT("Options -- Argument[%d] = %s."), i, buffer );
 
        //---------------------------------------------------------------------
        // If starts with / or -
        //---------------------------------------------------------------------
        if (( buffer[0]  == '/' ) || ( buffer[0]  == '-' )) {
 
            switch ( tolower( buffer[1] )) {
 
                //-------------------------------------------------------------
                // Retrieve the game's version info.
                //-------------------------------------------------------------
                case 'v':
                    {
                        char szPath   [ MAX_PATH ];
                        char szVersion[ MAX_PATH ];
 
                        Make_Current_Path_To( SETUP_INI_FILE1, szPath );
                        GetPrivateProfileString( "Setup", "Version", "1.0", szVersion, sizeof( szVersion ), szPath );
 
                        LoadString( Main::hInstance, IDS_VERSION_STRING, szBuffer,  MAX_PATH );
 
//                      sprintf( szBuffer3, "V %s", szVersion );
                        sprintf( szBuffer3, szBuffer, szVersion );
//                      strcpy( szBuffer, szRegistryKey );
 
                        MessageBox( NULL, szBuffer3, "Autorun", MB_TASKMODAL | MB_OK );
                        result = FALSE;
                    }
                    break;
 
                //-------------------------------------------------------------
                // Bypass the volume check.
                //-------------------------------------------------------------
                case 'n':
                    {
                        HANDLE  handle;
                        WIN32_FIND_DATA FindFileData;
 
                        memset( szVolumeName, '\0', MAX_PATH );
 
                        //-----------------------------------------------------
                        // If we think we are on CD2, then use PRODUCT_VOLUME_CD2.
                        //-----------------------------------------------------
                        Make_Current_Path_To( MOH_DEMO_PROGRAM, szBuffer );
                        handle = FindFirstFile( szBuffer, &FindFileData );
                        if ( handle == INVALID_HANDLE_VALUE ) {
                            strcpy( szVolumeName, PRODUCT_VOLUME_CD1 );
                        } else {
                            strcpy( szVolumeName, PRODUCT_VOLUME_CD2 );
                            FindClose( handle );    
                        }
 
                        strcpy( Arguments[ NumberArguments++ ], buffer );
                    }
                    break;
 
            #if( _DEBUG )
 
                case 'c':
                    if( buffer[2] == 'd' ) {
                        szCDDrive[0] = buffer[3];
                        szCDDrive[1] = ':';                     
                        szCDDrive[2] = '\\';
                    }
                    break;
 
                //-------------------------------------------------------------
                // Change languages?
                //-------------------------------------------------------------
                case 'l':
                    {
                        //-----------------------------------------------------
                        //  Identifier      Meaning 
                        //  932             Japan 
                        //  936             Chinese (PRC, Singapore) 
                        //  949             Korean 
                        //  1252            Windows 3.1 Latin 1 (US, Western Europe) 
                        //-----------------------------------------------------
                        char *temp = buffer+2;
                        int number = atoi( temp );
 
                        switch( number ) {
 
                                case LANG_GER:
                                    LanguageToUse = LANG_GER;
                                    CodePage = 1252;
                                    break;
 
                                case LANG_FRE:
                                    LanguageToUse = LANG_FRE;
                                    CodePage = 1252;
                                    break;
 
                                case LANG_JAP:
                                    LanguageToUse = LANG_JAP;
                                    CodePage = 932;
                                    break;
 
                                case LANG_KOR:
                                    LanguageToUse = LANG_KOR;
                                    CodePage = 949;
                                    break;
 
                                case LANG_CHI:
                                    LanguageToUse = LANG_CHI;
                                    CodePage = 950;
                                    break;
 
                                case LANG_USA:
                                default:
                                    LanguageToUse = LANG_USA;
                                    CodePage = 1252;
                                    break;
                        }
                    }
                    break;
 
 
            #endif
 
                default:
                    strcpy( Arguments[ NumberArguments++ ], buffer );
                    break;
            }
        }
    }
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("Options -- Language = %d"), Language );
    Msg( __LINE__, TEXT(__FILE__), TEXT("Options -- CodePage = %d"), CodePage );
 
#if(0)
    struct lconv *info = localeconv();
    char szDefaultLangID[ MAX_PATH ];
 
    GetLocaleInfo(
          LOCALE_USER_DEFAULT,  // locale identifier
          LOCALE_ILANGUAGE,     // type of information
          szBuffer1,           // address of buffer for information
          MAX_PATH );           // size of buffer
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("Options -- GetLocalInfo = %s"), szBuffer1 );
 
    sprintf( szDefaultLangID, "%04X", GetUserDefaultLangID());
    Msg( __LINE__, __FILE__, "Options -- GetUserDefaultLangID() = %s", szDefaultLangID );
 
    sprintf( szDefaultLangID, "%04X", GetSystemDefaultLangID());
    Msg( __LINE__, __FILE__, "Options -- GetSystemDefaultLangID() = %s", szDefaultLangID );
    Msg( __LINE__, __FILE__, "-------------------------------------------------------------" );
#endif
 
    return( result );
}
 
//*****************************************************************************
// Valid_Environment -- Make sure this program is run from CD-ROM disc only 
//                      AND it is a Win95 system.
//
// INPUT:       none.
//
//  OUTPUT:     none.
//
// WARNINGS:    returns 0 if ok to continue.
//
// HISTORY:                                                                
//   06/04/1996  MML : Created.                                            
//=============================================================================
 
BOOL Valid_Environment ( void )
{
    bool result = 0;
 
    //--------------------------------------------------------------------------
    // Check Windows Version.
    //--------------------------------------------------------------------------
 
    int length = 0;
    result = WinVersion.Meets_Minimum_Version_Requirements();
  if ( !result ) 
    {
        std::wstring wideBuffer = TheGameText->fetch("GUI:WindowsVersionText");
        std::wstring wideBuffer2 = TheGameText->fetch("GUI:WindowsVersionTitle");
        length = wideBuffer.length();
        WideCharToMultiByte( CodePage, 0, wideBuffer.c_str(), length+1, szBuffer, _MAX_PATH, NULL, NULL );
        length = wideBuffer2.length();
        WideCharToMultiByte( CodePage, 0, wideBuffer2.c_str(), length+1, szBuffer2, _MAX_PATH, NULL, NULL );
        MessageBox( NULL, szBuffer, szBuffer2, MB_APPLMODAL | MB_OK );
    }
 
    return( result );
}
 
//****************************************************************************
// LOADRESOURCEBITMAP -- Find & Load the bitmap from the resource.
//                                                                 
// INPUT:   HINSTANCE hInstance -- Program's hInstance.
//          LPTSTR lpString -- name of bitmap to find.
//          HPALETTE FAR *lphPalette -- we will return palette in this.
//
// OUTPUT:  HBITMAP -- handle to the bitmap if found.
//                                                                 
// WARNINGS:
//                                                                 
// HISTORY: Found this routine on MS Developmemt CD, July 1996.
//  09/26/1996  MML : Created.                                            
//=============================================================================
 
HBITMAP LoadResourceBitmap( HINSTANCE hInstance, LPTSTR lpString, HPALETTE FAR *lphPalette, bool loading_a_button )
{
//  HDC         hdc;
    int         iNumColors;
    HRSRC       hRsrc;
    HGLOBAL     hGlobal;
    HBITMAP     hBitmapFinal = NULL;
    LPBITMAPINFOHEADER lpbi;
 
    hBitmapFinal = LoadBitmap( hInstance, lpString );
 
    //--------------------------------------------------------------------------
    // Find the Bitmap in this program's resources.
    //--------------------------------------------------------------------------
    hRsrc = FindResource( hInstance, lpString, RT_BITMAP );
    if ( hRsrc ) {
 
        //-----------------------------------------------------------------------
        // Load the resource, lock the memory, grab a DC.
        //-----------------------------------------------------------------------
        hGlobal = LoadResource( hInstance, hRsrc );
        lpbi    = (LPBITMAPINFOHEADER) LockResource( hGlobal );
 
        if ( loading_a_button ) {
 
            //--------------------------------------------------------------------------
            // Set number of colors ( 2 to the nth ).
            //--------------------------------------------------------------------------
            if ( lpbi->biBitCount <= 8 ) {
                iNumColors = ( 1 << lpbi->biBitCount );
            } else {
                iNumColors = 0;
            }
 
        } else {
 
            //--------------------------------------------------------------------
            // Get the palette from the resource.  
            //--------------------------------------------------------------------
            *lphPalette = CreateDIBPalette((LPBITMAPINFO) lpbi, &iNumColors );
        }
 
        //-----------------------------------------------------------------------
        // Free DS and memory used.
        //-----------------------------------------------------------------------
        UnlockResource( hGlobal );
        FreeResource( hGlobal );
    }
 
    return( hBitmapFinal );
}
 
//*****************************************************************************
// CREATEDIBPALETTE -- Creates the palette from the Bitmap found above.
//                                                                 
// INPUT:   LPBITMAPINFO lpbmi -- bitmap info from header.
//          LPINT lpiNumColors -- number of colors.
//
// OUTPUT:  HPALETTE -- handle to the bitmap if found.
//                                                                 
// WARNINGS:                                                       
//                                                                 
// HISTORY: Found this routine on MS Developmemt CD, July 1996.
//  09/26/1996  MML : Created.                                            
//=============================================================================
HPALETTE CreateDIBPalette ( LPBITMAPINFO lpbmi, LPINT lpiNumColors )
{
    LPBITMAPINFOHEADER lpbi;
    LPLOGPALETTE lpPal;
    HANDLE hLogPal;
    HPALETTE hPal = NULL;
    int i;
 
    lpbi = (LPBITMAPINFOHEADER) lpbmi;
 
    //--------------------------------------------------------------------------
    // Set number of colors ( 2 to the nth ).
    //--------------------------------------------------------------------------
    if ( lpbi->biBitCount <= 8 ) {
        *lpiNumColors = ( 1 << lpbi->biBitCount );
    } else {
        *lpiNumColors = 0;
    }
 
    //--------------------------------------------------------------------------
    // If bitmap has a palette ( bitcount ), lock some memory and create
    // a palette from the bitmapinfoheader passed in.
    //--------------------------------------------------------------------------
    if ( *lpiNumColors ) {
 
        hLogPal = GlobalAlloc( GHND, sizeof( LOGPALETTE ) + sizeof( PALETTEENTRY ) * ( *lpiNumColors ));
        lpPal   = (LPLOGPALETTE) GlobalLock( hLogPal );
        lpPal->palVersion   = 0x300;
        lpPal->palNumEntries = (WORD)*lpiNumColors;
 
        for ( i = 0; i < *lpiNumColors; i++ ) {
            lpPal->palPalEntry[i].peRed   = lpbmi->bmiColors[i].rgbRed;
            lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
            lpPal->palPalEntry[i].peBlue  = lpbmi->bmiColors[i].rgbBlue;
            lpPal->palPalEntry[i].peFlags = 0;
        }
        hPal = CreatePalette( lpPal );
        GlobalUnlock( hLogPal );
        GlobalFree( hLogPal );
 
#if(0)
        StandardFileClass fileout;
        char buff[2];
 
        fileout.Open( "test.pal", MODE_WRITE_TRUNCATE );
        for ( i = 0; i < *lpiNumColors; i++ ) {
            sprintf( buff, "%d", lpPal->palPalEntry[i].peRed >> 2 );
            fileout.Write(( void *)buff, 2 );
            sprintf( buff, "%d", lpPal->palPalEntry[i].peGreen >> 2 );
            fileout.Write(( void *)buff, 2 );
            sprintf( buff, "%d", lpPal->palPalEntry[i].peBlue >> 2 );
            fileout.Write(( void *)buff, 2 );
        }
        fileout.Close();
#endif
 
    }
    return( hPal ); 
}
 
//*****************************************************************************
// LOADRESOURCEBUTTON -- Find & Load the bitmap from the resource.
//                                                                 
// INPUT:   HINSTANCE hInstance -- Program's hInstance.
//          LPTSTR lpString -- name of bitmap to find.
//          HPALETTE FAR *lphPalette -- we will return palette in this.
//
// OUTPUT:  HBITMAP -- handle to the bitmap if found.
//                                                                 
// WARNINGS:
//                                                                 
// HISTORY: Found this routine on MS Developmemt CD, July 1996.
//  09/26/1996  MML : Created.                                            
//=============================================================================
HBITMAP LoadResourceButton( HINSTANCE hInstance, LPTSTR lpString, HPALETTE FAR lphPalette )
{
    HDC         hdc;
    int         iNumColors;
    HRSRC   hRsrc;
    HGLOBAL     hGlobal;
    HBITMAP     hBitmapFinal = NULL;
    LPBITMAPINFOHEADER lpbi;
 
    //--------------------------------------------------------------------------
    // Find the Bitmap in this program's resources.
    //--------------------------------------------------------------------------
    hRsrc = FindResource( hInstance, lpString, RT_BITMAP );
    if ( hRsrc ) {
 
        //-----------------------------------------------------------------------
        // Load the resource, lock the memory, grab a DC.
        //-----------------------------------------------------------------------
        hGlobal = LoadResource( hInstance, hRsrc );
        lpbi        = (LPBITMAPINFOHEADER) LockResource( hGlobal );
        hdc     = GetDC( NULL );
 
        //--------------------------------------------------------------------------
        // Set number of colors ( 2 to the nth ).
        //--------------------------------------------------------------------------
        if ( lpbi->biBitCount <= 8 ) {
            iNumColors = ( 1 << lpbi->biBitCount );
        } else {
            iNumColors = 0;
        }
 
        //-----------------------------------------------------------------------
        // Get the palette from the resource.  
        // Select to the DC and realize it in the System palette.
        //-----------------------------------------------------------------------
//      *lphPalette = CreateDIBPalette((LPBITMAPINFO) lpbi, &iNumColors );
        if ( lphPalette != NULL ) {
            SelectPalette( hdc, lphPalette, FALSE );
            RealizePalette( hdc );
        }
 
        //-----------------------------------------------------------------------
        // Now create the bitmap itself.
        //-----------------------------------------------------------------------
        hBitmapFinal = CreateDIBitmap( 
                        hdc, 
                        (LPBITMAPINFOHEADER)lpbi,
                        (LONG)CBM_INIT,
                        (LPTSTR)lpbi + lpbi->biSize + iNumColors * sizeof( RGBQUAD ),
                        (LPBITMAPINFO)lpbi,
                        DIB_RGB_COLORS );
 
        //-----------------------------------------------------------------------
        // Free DS and memory used.
        //-----------------------------------------------------------------------
        ReleaseDC( NULL, hdc );                        
        UnlockResource( hGlobal );
        FreeResource( hGlobal );
    }
    return( hBitmapFinal );
}
 
//*****************************************************************************
// Cant_Find_MessageBox -- Find & Load the bitmap from the resource.
//                                                                 
// INPUT:   HINSTANCE hInstance -- Program's hInstance.
//          LPTSTR lpString -- name of bitmap to find.
//          HPALETTE FAR *lphPalette -- we will return palette in this.
//
// OUTPUT:  HBITMAP -- handle to the bitmap if found.
//                                                                 
// WARNINGS:
//                                                                 
// HISTORY: Found this routine on MS Developmemt CD, July 1996.
//  09/26/1996  MML : Created.  
//  08/27/2003  JFS : Repaired!                                          
//=============================================================================
 
void Cant_Find_MessageBox ( HINSTANCE hInstance, char *szPath )
{
 
    //
    // JFS... Added functionality to make this work in wide characters.
    //
#ifdef LEAN_AND_MEAN
    {
        Locale_GetString( "Autorun:AutorunTitle", szWideBuffer );
        swprintf( szWideBuffer3, szWideBuffer, szProductName );
 
        Locale_GetString( "Autorun:CantFind", szWideBuffer );
        MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, szPath, _MAX_PATH, szWideBuffer0, _MAX_PATH );
        swprintf( szWideBuffer2, szWideBuffer, szWideBuffer0 );   
 
        MessageBoxW( NULL,  szWideBuffer2, szWideBuffer3, MB_APPLMODAL | MB_OK );
    }
 
#else
 
    std::wstring wideBuffer = TheGameText->fetch("Autorun:AutorunTitle");
    std::wstring wideBuffer2.format( wideBuffer.str(), productName.str() );
    std::wstring wideBuffer3 = TheGameText->fetch("Autorun:CantFind");
 
    WideCharToMultiByte( CodePage, 0, wideBuffer3.str(), wideBuffer3.getLength()+1, szBuffer3, _MAX_PATH, NULL, NULL );
    WideCharToMultiByte( CodePage, 0, wideBuffer2.str(), wideBuffer2.getLength()+1, szBuffer2, _MAX_PATH, NULL, NULL );
 
 
    sprintf( szBuffer1, szBuffer3, szPath );
 
 
    if ( strlen( szPath ) < 3 )
    {
        MessageBox( NULL, "The path specified in Cant_Find_MessageBox was blank", "Autorun", MB_APPLMODAL | MB_OK );
        return;
    }   
    if ( strlen( szBuffer1 ) < 3 && strlen( szBuffer3 ) < 3 )
    {
        MessageBox( NULL, "***MISSING MESSAGES***... IDS_AUTORUN_TITLE and IDS_CANT_FIND", "Autorun", MB_APPLMODAL | MB_OK );
        return;
    }   
    if ( strlen( szBuffer1 ) < 3 )
    {
        MessageBox( NULL, "***MISSING MESSAGE***... IDS_AUTORUN_TITLE", "Autorun", MB_APPLMODAL | MB_OK );
        return;
    }   
    if ( strlen( szBuffer3 ) < 3 )
    {
        MessageBox( NULL, "***MISSING MESSAGE***... IDS_CANT_FIND", "Autorun", MB_APPLMODAL | MB_OK );
        return;
    }
 
 
 
 
    MessageBox( NULL, szBuffer1, szBuffer2, MB_APPLMODAL | MB_OK );
#endif
 
}
 
 
/****************************************************************************** 
 * Error_Message --                                                           
 *                                                                            
 * INPUT:                                                                     
 *                                                                            
 * OUTPUT:      
 *                                                                            
 * WARNINGS:   none                                                           
 *                                                                            
 * HISTORY:                                                                   
 *   08/14/1998 MML : Created.                                                
 *============================================================================*/
 
void Error_Message ( HINSTANCE hInstance, const char * title, const char * string, char *path )
{
 
#ifndef LEAN_AND_MEAN
 
    wideBuffer2 = TheGameText->fetch(title);
    wideBuffer3 = TheGameText->fetch(string);
 
    if ( path && ( path[0] != '\0' )) 
    {
        wideBuffer3.format( wideBuffer.str(), path );
    } 
    else 
    {
        wideBuffer3 = wideBuffer;                   // insert not provided
    }
 
    WideCharToMultiByte( CodePage, 0, wideBuffer2.str(), wideBuffer2.getLength()+1, szBuffer2, _MAX_PATH, NULL, NULL );
    WideCharToMultiByte( CodePage, 0, wideBuffer3.str(), wideBuffer3.getLength()+1, szBuffer3, _MAX_PATH, NULL, NULL );
 
    MessageBox( NULL, szBuffer3, szBuffer2, MB_APPLMODAL | MB_OK );
 
#endif
 
    MessageBox( NULL, "ERROR_UNDEFINED", "ERROR_UNDEFINED", MB_APPLMODAL | MB_OK );
 
 
}
 
 
/****************************************************************************** 
/ Launch Class Object
/******************************************************************************/
 
LaunchObjectClass::LaunchObjectClass ( char *path, char *args )
{
    memset( szPath, '\0', _MAX_PATH );
    memset( szArgs, '\0', _MAX_PATH );
 
    if( path != NULL && path[0] != '\0' ) {
        strcpy( szPath, path );
    }
    if( args != NULL && args[0] != '\0' ) {
        strcpy( szArgs, args );
    }
}
 
void LaunchObjectClass::SetPath ( char *path )
{
    if( path != NULL && path[0] != '\0' ) {
        memset( szPath, '\0', _MAX_PATH );
        strcpy( szPath, path );
    }
}
 
void LaunchObjectClass::SetArgs ( char *args )
{
    if( args != NULL && args[0] != '\0' ) {
        memset( szArgs, '\0', _MAX_PATH );
        strcpy( szArgs, args );
    }
}
 
unsigned int LaunchObjectClass::Launch ( void )
{
    char    filepath    [_MAX_PATH];
    char    dir          [_MAX_DIR];
    char    ext         [_MAX_EXT];
    char    drive      [_MAX_DRIVE];
    char    file        [_MAX_FNAME];
    char    lpszComLine [ 127 ];
 
    PROCESS_INFORMATION processinfo; 
    STARTUPINFO         startupinfo;
    unsigned int        abc = 0;
    unsigned int        result = 0;
 
    memset( lpszComLine, '\0', 127 );
 
    //--------------------------------------------------------------------------
    // Split into parts.
    //--------------------------------------------------------------------------
    _splitpath( szPath, drive, dir, file, ext );
 
    //--------------------------------------------------------------------------
    // Change current path to the correct dir.
    //
    // The _chdrive function changes the current working drive to the drive 
    // specified by drive. The drive parameter uses an integer to specify the 
    // new working drive (1=A, 2=B, and so forth). This function changes only 
    // the working drive; _chdir changes the working directory.
    //--------------------------------------------------------------------------
    _makepath( filepath, drive, dir, NULL, NULL );
    Path_Remove_Back_Slash( filepath );
 
    abc = (unsigned)( toupper( filepath[0] ) - 'A' + 1 );
    if ( !_chdrive( abc )) {
 
        //----------------------------------------------------------------------
        // Returns a value of 0 if successful.
        //----------------------------------------------------------------------
        abc = _chdir( filepath );
    }
 
#if (_DEBUG)
 
    int cde = _getdrive();
    _getcwd( szBuffer, _MAX_PATH );
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("Current Working Dir = %d\\%s." ), cde, szBuffer );
#endif
 
    //--------------------------------------------------------------------------
    // Try to launch the EXE...
    //--------------------------------------------------------------------------
    _stprintf( lpszComLine, _TEXT( "%s %s" ), szPath, szArgs );
 
    //==========================================================================
    // Setup the call
    //==========================================================================
    memset( &startupinfo, 0, sizeof( STARTUPINFO ));
    startupinfo.cb = sizeof( STARTUPINFO );
 
    Msg( __LINE__, TEXT(__FILE__), TEXT("About to launch %s." ), lpszComLine );
 
    result = CreateProcess( 
                szPath,                                               // address of module name
                lpszComLine,                                        // address of command line
                NULL,                                               // address of process security attributes
                NULL,                                               // address of thread security attributes
                FALSE,                                             // new process inherits handles
                FALSE,
                NULL,                                               // address of new environment block
                NULL,                                               // address of current directory name
                &startupinfo,                                       // address of STARTUPINFO
                &processinfo );                                     // address of PROCESS_INFORMATION
 
    //--------------------------------------------------------------------------
    // If WinExec returned 0, error occurred.
    //--------------------------------------------------------------------------
    if ( !result ) {
 
        Msg( __LINE__, TEXT(__FILE__), TEXT("Launch of %s failed." ), lpszComLine );
        _makepath ( filepath, NULL, NULL, file, ext );
        Cant_Find_MessageBox ( Main::hInstance, filepath );
    }
    Msg( __LINE__, TEXT(__FILE__), TEXT("Launch of %s succeeded." ), lpszComLine );
 
    return( result );
}
 
void Debug_Date_And_Time_Stamp ( void )
{
    //-------------------------------------------------------------------------
    //  tm_sec  - Seconds after minute (0 – 59)
    //  tm_min  - Minutes after hour (0 – 59)
    //  tm_hour - Hours after midnight (0 – 23)
    //  tm_mday - Day of month (1 – 31)
    //  tm_mon  - Month (0 – 11; January = 0)
    //  tm_year - Year (current year minus 1900)
    //  tm_wday - Day of week (0 – 6; Sunday = 0)
    //  tm_yday - Day of year (0 – 365; January 1 = 0)
    //-------------------------------------------------------------------------
    static char *Month_Strings[ 12 ] = {
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December"
    };
 
    static char *Week_Day_Strings[ 7 ] = {
        "Sunday",
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday",
        "Saturday",
    };
 
    char        ampm[] = "AM";
    time_t        ltime;
    struct tm * today;
 
    /*-------------------------------------------------------------------------
     *Convert to time structure and adjust for PM if necessary. 
     */
    time( &ltime );
    today = localtime( &ltime );
    if( today->tm_hour > 12 ) {
        strcpy( ampm, "PM" );
        today->tm_hour -= 12;
    }
    if( today->tm_hour == 0 ) {     /* Adjust if midnight hour. */
        today->tm_hour = 12;
    }
 
    Msg( __LINE__, __FILE__, "%s, %s %d, %d      %d:%d:%d %s", 
        Week_Day_Strings[ today->tm_wday ],
        Month_Strings[ today->tm_mon ],
        today->tm_mday,     
        today->tm_year + 1900,
        today->tm_hour, 
        today->tm_min, 
        today->tm_sec, 
        ampm );
 
    /*-------------------------------------------------------------------------
     * Note how pointer addition is used to skip the first 11 
     * characters and printf is used to trim off terminating 
     * characters.
     */
//  Msg( __LINE__, __FILE__, "%s %s\n", asctime( today ), ampm );
}
 
 
bool Is_On_CD ( char *volume_name )
{
    char volume_to_match[ MAX_PATH ];
 
    Reformat_Volume_Name( volume_name, volume_to_match );
 
    if( _stricmp( szVolumeName, volume_to_match ) == 0 ) {
        return true;
    } else {
        return false;
    }
}
 
bool Prompt_For_CD ( HWND window_handle, char *volume_name, const char * message1, const char * message2, int *cd_drive )
{
    int drive;
 
    strcpy( szBuffer, Args->Get_argv( 0 ));
    drive = toupper( szBuffer[0] ) - 'A';
    memset( szBuffer, '\0', MAX_PATH );
 
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // This is the correct check for a CD Check.
    //
    // MML: Modified on 10/18/2000 so it would check for all available CD drives.
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    int result = IDRETRY;
 
    while( result == IDRETRY ) {
 
            if ( CD_Volume_Verification( drive, szBuffer, volume_name )) {
 
                result = IDOK;
                *cd_drive = drive;
 
            } else {
 
                CDList.Reset_Index();
 
                while(( result == IDRETRY ) && ( CDList.Get_Index() < CDList.Get_Number_Of_Drives())) {
 
                    drive = CDList.Get_Next_CD_Drive();
 
                    if ( CD_Volume_Verification( drive, szBuffer, volume_name )) {
                        result = IDOK;
                        *cd_drive = drive;
                    }
                }
            }
 
            if ( result == IDRETRY ) {
                result = ( Show_Message( window_handle, message1, message2 ));
            }
    }
 
    if ( result == IDCANCEL ) {
        return( false );
//      return true;
    }
 
    return( true );
}
 
 
 
int Show_Message ( HWND window_handle, const char * message1, const char * message2 )
{
 
#ifndef LEAN_AND_MEAN
 
    UnicodeString  string1;
    UnicodeString  string2;
    WCHAR   szString3[ MAX_PATH ];
    int     result = false;
 
    string1 = TheGameText->fetch(message1);
    string2 = TheGameText->fetch(message2);
 
    wcscpy( szString3, string1.str() );
    wcscat( szString3, L" " );
    wcscat( szString3, string2.str() );
 
    WideCharToMultiByte( CodePage, 0, szString3, _MAX_PATH, szBuffer, _MAX_PATH, NULL, NULL );
    result = MessageBox( window_handle, szBuffer, "Autorun", MB_RETRYCANCEL|MB_APPLMODAL|MB_SETFOREGROUND );
 
    return( result );
 
#else
 
    return ( 0 );
 
#endif
 
}
 
 
void Reformat_Volume_Name ( char *volume_name, char *new_volume_name )
{
    char temp_volume_name[ MAX_PATH ];
 
    strcpy( temp_volume_name, volume_name );
 
    if( WinVersion.Is_Win95()) {
        temp_volume_name[11] = '\0';
    }
 
    if( new_volume_name != NULL ) {
        strcpy( new_volume_name, temp_volume_name );
    }
}