console.c File Reference

#include "resource.h"

Include dependency graph for console.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_VDM_MENUITEM

Typedefs
typedef struct _VDM_MENUITEM	VDM_MENUITEM
typedef struct _VDM_MENUITEM *	PVDM_MENUITEM

Functions
static VOID	AppendMenuItems (HMENU hMenu, const VDM_MENUITEM *Items)
static BOOL	VdmMenuExists (HMENU hConsoleMenu)
static VOID	UpdateVdmMenuMouse (VOID)
VOID	UpdateVdmMenuDisks (VOID)
static VOID	UpdateVdmMenu (VOID)
static VOID	CreateVdmMenu (HANDLE ConOutHandle)
static VOID	DestroyVdmMenu (VOID)
static VOID	CaptureMousePointer (HANDLE ConOutHandle, BOOLEAN Capture)
static VOID	EnableExtraHardware (HANDLE ConsoleInput)
VOID	VdmShutdown (BOOLEAN Immediate)
static BOOL WINAPI	ConsoleCtrlHandler (DWORD ControlType)
static VOID	ConsoleInitUI (VOID)
static VOID	ConsoleCleanupUI (VOID)
BOOL	ConsoleAttach (VOID)
VOID	ConsoleDetach (VOID)
VOID	ConsoleReattach (HANDLE ConOutHandle)
static BOOL	ConsoleInit (VOID)
static VOID	ConsoleCleanup (VOID)
BOOL	IsConsoleHandle (HANDLE hHandle)
VOID	MenuEventHandler (PMENU_EVENT_RECORD MenuEvent)
VOID	FocusEventHandler (PFOCUS_EVENT_RECORD FocusEvent)

Variables
static HANDLE	CurrentConsoleOutput = INVALID_HANDLE_VALUE
static HANDLE	ConsoleInput = INVALID_HANDLE_VALUE
static HANDLE	ConsoleOutput = INVALID_HANDLE_VALUE
static DWORD	OrgConsoleInputMode
static DWORD	OrgConsoleOutputMode
HWND	hConsoleWnd = NULL
static HMENU	hConsoleMenu = NULL
static INT	VdmMenuPos = -1
static BOOL	CaptureMouse = FALSE
static const VDM_MENUITEM	VdmMenuItems []
static const VDM_MENUITEM	VdmMainMenuItems []

Typedef Documentation

PVDM_MENUITEM

typedef struct _VDM_MENUITEM * PVDM_MENUITEM

VDM_MENUITEM

typedef struct _VDM_MENUITEM VDM_MENUITEM

Function Documentation

AppendMenuItems()

static VOID AppendMenuItems ( HMENU  hMenu, const VDM_MENUITEM *  Items  )

static

Definition at line 58 of file console.c.

{
    UINT i = 0;
    WCHAR szMenuString[256];
    HMENU hSubMenu;
 
    do
    {
        if (Items[i].uID != (UINT)-1)
        {
            if (LoadStringW(GetModuleHandle(NULL),
                            Items[i].uID,
                            szMenuString,
                            ARRAYSIZE(szMenuString)) > 0)
            {
                if (Items[i].SubMenu != NULL)
                {
                    hSubMenu = CreatePopupMenu();
                    if (hSubMenu != NULL)
                    {
                        AppendMenuItems(hSubMenu, Items[i].SubMenu);
 
                        if (!AppendMenuW(hMenu,
                                         MF_STRING | MF_POPUP,
                                         (UINT_PTR)hSubMenu,
                                         szMenuString))
                        {
                            DestroyMenu(hSubMenu);
                        }
                    }
                }
                else
                {
                    AppendMenuW(hMenu,
                                MF_STRING,
                                Items[i].uCmdID,
                                szMenuString);
                }
            }
        }
        else
        {
            AppendMenuW(hMenu,
                        MF_SEPARATOR,
                        0,
                        NULL);
        }
        i++;
    } while (!(Items[i].uID == 0 && Items[i].SubMenu == NULL && Items[i].uCmdID == 0));
}

Referenced by AppendMenuItems(), and CreateVdmMenu().

CaptureMousePointer()

static VOID CaptureMousePointer ( HANDLE  ConOutHandle, BOOLEAN  Capture  )

static

Definition at line 288 of file console.c.

{
    static BOOL IsClipped = FALSE; // For debugging purposes
    UNREFERENCED_PARAMETER(IsClipped);
 
    if (Capture)
    {
        RECT rcClip;
 
        // if (IsClipped) return;
 
        /* Be sure the cursor will be hidden */
        while (ShowConsoleCursor(ConOutHandle, FALSE) >= 0) ;
 
        GetClientRect(hConsoleWnd, &rcClip);
        MapWindowPoints(hConsoleWnd, HWND_DESKTOP /*NULL*/, (LPPOINT)&rcClip, 2 /* Magic value when the LPPOINT parameter is a RECT */);
        IsClipped = ClipCursor(&rcClip);
    }
    else
    {
        // if (!IsClipped) return;
 
        ClipCursor(NULL);
        IsClipped = FALSE;
 
        /* Be sure the cursor will be shown */
        while (ShowConsoleCursor(ConOutHandle, TRUE) < 0) ;
    }
}

Referenced by ConsoleCleanupUI(), ConsoleReattach(), FocusEventHandler(), and MenuEventHandler().

ConsoleAttach()

BOOL ConsoleAttach

(

VOID

)

Definition at line 398 of file console.c.

{
    /* Save the original input and output console modes */
    if (!GetConsoleMode(ConsoleInput , &OrgConsoleInputMode ) ||
        !GetConsoleMode(ConsoleOutput, &OrgConsoleOutputMode))
    {
        CloseHandle(ConsoleOutput);
        CloseHandle(ConsoleInput);
        wprintf(L"FATAL: Cannot save console in/out modes\n");
        return FALSE;
    }
 
    /* Set the console input mode */
    SetConsoleMode(ConsoleInput, ENABLE_WINDOW_INPUT);
    EnableExtraHardware(ConsoleInput);
 
    /* Set the console output mode */
    // SetConsoleMode(ConsoleOutput, ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
 
    /* Initialize the UI */
    ConsoleInitUI();
 
    return TRUE;
}

Referenced by ConsoleInit(), and DosProcessConsoleAttach().

ConsoleCleanup()

static VOID ConsoleCleanup ( VOID  )

static

Definition at line 493 of file console.c.

{
    /* Detach from the console */
    ConsoleDetach();
 
    /* Close the console handles */
    if (ConsoleOutput != INVALID_HANDLE_VALUE) CloseHandle(ConsoleOutput);
    if (ConsoleInput  != INVALID_HANDLE_VALUE) CloseHandle(ConsoleInput);
}

ConsoleCleanupUI()

static VOID ConsoleCleanupUI ( VOID  )

static

Definition at line 389 of file console.c.

{
    /* Display again properly the mouse pointer */
    if (CaptureMouse) CaptureMousePointer(ConsoleOutput, !CaptureMouse);
 
    DestroyVdmMenu();
}

Referenced by ConsoleDetach().

ConsoleCtrlHandler()

static BOOL WINAPI ConsoleCtrlHandler ( DWORD  ControlType )

static

Definition at line 359 of file console.c.

{
    switch (ControlType)
    {
        case CTRL_LAST_CLOSE_EVENT:
        {
            /* Delayed shutdown */
            DPRINT1("NTVDM delayed killing in the CTRL_LAST_CLOSE_EVENT CtrlHandler!\n");
            VdmShutdown(FALSE);
            break;
        }
 
        default:
        {
            /* Stop the VDM if the user logs out or closes the console */
            DPRINT1("Killing NTVDM in the 'default' CtrlHandler!\n");
            VdmShutdown(TRUE);
        }
    }
    return TRUE;
}

Referenced by ConsoleInit().

ConsoleDetach()

VOID ConsoleDetach

(

VOID

)

Definition at line 424 of file console.c.

{
    /* Cleanup the UI */
    ConsoleCleanupUI();
 
    /* Restore the original input and output console modes */
    SetConsoleMode(ConsoleOutput, OrgConsoleOutputMode);
    SetConsoleMode(ConsoleInput , OrgConsoleInputMode );
}

Referenced by ConsoleCleanup(), and DosProcessConsoleDetach().

ConsoleInit()

static BOOL ConsoleInit ( VOID  )

static

Definition at line 446 of file console.c.

{
    /* Set the handler routine */
    SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
 
    /* Enable the CTRL_LAST_CLOSE_EVENT */
    SetLastConsoleEventActive();
 
    /*
     * NOTE: The CONIN$ and CONOUT$ "virtual" files
     * always point to non-redirected console handles.
     */
 
    /* Get the input handle to the real console, and check for success */
    ConsoleInput = CreateFileW(L"CONIN$",
                               GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ | FILE_SHARE_WRITE,
                               NULL,
                               OPEN_EXISTING,
                               0,
                               NULL);
    if (ConsoleInput == INVALID_HANDLE_VALUE)
    {
        wprintf(L"FATAL: Cannot retrieve a handle to the console input\n");
        return FALSE;
    }
 
    /* Get the output handle to the real console, and check for success */
    ConsoleOutput = CreateFileW(L"CONOUT$",
                                GENERIC_READ | GENERIC_WRITE,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                NULL,
                                OPEN_EXISTING,
                                0,
                                NULL);
    if (ConsoleOutput == INVALID_HANDLE_VALUE)
    {
        CloseHandle(ConsoleInput);
        wprintf(L"FATAL: Cannot retrieve a handle to the console output\n");
        return FALSE;
    }
 
    /* Effectively attach to the console */
    return ConsoleAttach();
}

Referenced by wmain().

ConsoleInitUI()

static VOID ConsoleInitUI ( VOID  )

static

Definition at line 382 of file console.c.

{
    hConsoleWnd = GetConsoleWindow();
    CreateVdmMenu(ConsoleOutput);
}

Referenced by ConsoleAttach().

ConsoleReattach()

VOID ConsoleReattach

(

HANDLE

ConOutHandle

)

Definition at line 435 of file console.c.

{
    DestroyVdmMenu();
    CurrentConsoleOutput = ConOutHandle;
    CreateVdmMenu(ConOutHandle);
 
    /* Synchronize mouse cursor display with console screenbuffer switches */
    CaptureMousePointer(CurrentConsoleOutput, CaptureMouse);
}

Referenced by SetActiveScreenBuffer().

CreateVdmMenu()

static VOID CreateVdmMenu ( HANDLE  ConOutHandle )

static

Definition at line 203 of file console.c.

{
    HMENU hVdmSubMenu;
    UINT_PTR ItemID;
    UINT Pos;
    USHORT i;
    WCHAR szNoMedia[100];
    WCHAR szMenuString1[256], szMenuString2[256];
 
    hConsoleMenu = ConsoleMenuControl(ConOutHandle,
                                      ID_CAPTURE_MOUSE,
                                      ID_VDM_DRIVES + (2 * ARRAYSIZE(GlobalSettings.FloppyDisks)));
    if (hConsoleMenu == NULL) return;
 
    /* Get the position where we are going to insert our menu items */
    VdmMenuPos = GetMenuItemCount(hConsoleMenu);
 
    /* Really add the menu if it doesn't already exist (in case eg. NTVDM crashed) */
    if (!VdmMenuExists(hConsoleMenu))
    {
        /* Add all the menu entries */
        AppendMenuItems(hConsoleMenu, VdmMainMenuItems);
 
        /* Add the removable drives menu entries */
        hVdmSubMenu = GetSubMenu(hConsoleMenu, VdmMenuPos + 2); // VdmMenuItems
        Pos = 3; // After the 2 items and the separator in VdmMenuItems
 
        LoadStringW(GetModuleHandle(NULL),
                    IDS_NO_MEDIA,
                    szNoMedia,
                    ARRAYSIZE(szNoMedia));
 
        LoadStringW(GetModuleHandle(NULL),
                    IDS_VDM_MOUNT_FLOPPY,
                    szMenuString1,
                    ARRAYSIZE(szMenuString1));
 
        /* Drive 'x' -- Mount */
        for (i = 0; i < ARRAYSIZE(GlobalSettings.FloppyDisks); ++i)
        {
            ItemID = ID_VDM_DRIVES + (2 * i);
 
            /* Add the item */
            _snwprintf(szMenuString2, ARRAYSIZE(szMenuString2), szMenuString1, i, szNoMedia);
            szMenuString2[ARRAYSIZE(szMenuString2) - 1] = UNICODE_NULL;
            InsertMenuW(hVdmSubMenu, Pos++, MF_STRING | MF_BYPOSITION, ItemID, szMenuString2);
        }
 
        LoadStringW(GetModuleHandle(NULL),
                    IDS_VDM_EJECT_FLOPPY,
                    szMenuString1,
                    ARRAYSIZE(szMenuString1));
 
        /* Drive 'x' -- Eject */
        for (i = 0; i < ARRAYSIZE(GlobalSettings.FloppyDisks); ++i)
        {
            ItemID = ID_VDM_DRIVES + (2 * i);
 
            /* Add the item */
            _snwprintf(szMenuString2, ARRAYSIZE(szMenuString2), szMenuString1, i);
            szMenuString2[ARRAYSIZE(szMenuString2) - 1] = UNICODE_NULL;
            InsertMenuW(hVdmSubMenu, Pos++, MF_STRING | MF_BYPOSITION, ItemID + 1, szMenuString2);
        }
 
        /* Refresh the menu state */
        UpdateVdmMenu();
        DrawMenuBar(hConsoleWnd);
    }
}

Referenced by ConsoleInitUI(), and ConsoleReattach().

DestroyVdmMenu()

static VOID DestroyVdmMenu ( VOID  )

static

Definition at line 274 of file console.c.

{
    UINT i = 0;
    const VDM_MENUITEM *Items = VdmMainMenuItems;
 
    do
    {
        DeleteMenu(hConsoleMenu, VdmMenuPos, MF_BYPOSITION);
        i++;
    } while (!(Items[i].uID == 0 && Items[i].SubMenu == NULL && Items[i].uCmdID == 0));
 
    DrawMenuBar(hConsoleWnd);
}

Referenced by ConsoleCleanupUI(), and ConsoleReattach().

EnableExtraHardware()

static VOID EnableExtraHardware ( HANDLE  ConsoleInput )

static

Definition at line 318 of file console.c.

{
    DWORD ConInMode;
 
    if (GetConsoleMode(ConsoleInput, &ConInMode))
    {
#if 0
        // GetNumberOfConsoleMouseButtons();
        // GetSystemMetrics(SM_CMOUSEBUTTONS);
        // GetSystemMetrics(SM_MOUSEPRESENT);
        if (MousePresent)
        {
#endif
            /* Support mouse input events if there is a mouse on the system */
            ConInMode |= ENABLE_MOUSE_INPUT;
#if 0
        }
        else
        {
            /* Do not support mouse input events if there is no mouse on the system */
            ConInMode &= ~ENABLE_MOUSE_INPUT;
        }
#endif
 
        SetConsoleMode(ConsoleInput, ConInMode);
    }
}

Referenced by ConsoleAttach().

FocusEventHandler()

VOID FocusEventHandler

(

PFOCUS_EVENT_RECORD

FocusEvent

)

Definition at line 600 of file console.c.

{
    /*
     * If the mouse is captured, release it or recapture it
     * when we lose or regain focus, respectively.
     */
    if (!CaptureMouse) return;
    CaptureMousePointer(CurrentConsoleOutput, FocusEvent->bSetFocus);
}

Referenced by ConsoleEventThread().

IsConsoleHandle()

BOOL IsConsoleHandle

(

HANDLE

hHandle

)

Definition at line 503 of file console.c.

{
    DWORD dwMode;
 
    /* Check whether the handle may be that of a console... */
    if ((GetFileType(hHandle) & ~FILE_TYPE_REMOTE) != FILE_TYPE_CHAR)
        return FALSE;
 
    /*
     * It may be. Perform another test... The idea comes from the
     * MSDN description of the WriteConsole API:
     *
     * "WriteConsole fails if it is used with a standard handle
     *  that is redirected to a file. If an application processes
     *  multilingual output that can be redirected, determine whether
     *  the output handle is a console handle (one method is to call
     *  the GetConsoleMode function and check whether it succeeds).
     *  If the handle is a console handle, call WriteConsole. If the
     *  handle is not a console handle, the output is redirected and
     *  you should call WriteFile to perform the I/O."
     */
    return GetConsoleMode(hHandle, &dwMode);
}

MenuEventHandler()

VOID MenuEventHandler

(

PMENU_EVENT_RECORD

MenuEvent

)

Definition at line 527 of file console.c.

{
    switch (MenuEvent->dwCommandId)
    {
        /*
         * System-defined menu commands
         */
 
        case WM_INITMENU:
        case WM_MENUSELECT:
        {
            /*
             * If the mouse is captured, release it or recapture it
             * when the menu opens or closes, respectively.
             */
            if (!CaptureMouse) break;
            CaptureMousePointer(CurrentConsoleOutput, MenuEvent->dwCommandId == WM_INITMENU ? FALSE : TRUE);
            break;
        }
 
 
        /*
         * User-defined menu commands
         */
 
        case ID_CAPTURE_MOUSE:
            CaptureMouse = !CaptureMouse;
            CaptureMousePointer(CurrentConsoleOutput, CaptureMouse);
            UpdateVdmMenuMouse();
            break;
 
        case ID_VDM_DUMPMEM_TXT:
            DumpMemory(TRUE);
            break;
 
        case ID_VDM_DUMPMEM_BIN:
            DumpMemory(FALSE);
            break;
 
        /* Drive 0 -- Mount */
        /* Drive 1 -- Mount */
        case ID_VDM_DRIVES + 0:
        case ID_VDM_DRIVES + 2:
        {
            ULONG DiskNumber = (MenuEvent->dwCommandId - ID_VDM_DRIVES) / 2;
            MountFloppy(DiskNumber);
            break;
        }
 
        /* Drive 0 -- Eject */
        /* Drive 1 -- Eject */
        case ID_VDM_DRIVES + 1:
        case ID_VDM_DRIVES + 3:
        {
            ULONG DiskNumber = (MenuEvent->dwCommandId - ID_VDM_DRIVES - 1) / 2;
            EjectFloppy(DiskNumber);
            break;
        }
 
        case ID_VDM_QUIT:
            /* Stop the VDM */
            // EmulatorTerminate();
 
            /* Nothing runs, so exit immediately */
            DPRINT1("Killing NTVDM via console menu!\n");
            VdmShutdown(TRUE);
            break;
 
        default:
            break;
    }
}

Referenced by ConsoleEventThread().

UpdateVdmMenu()

static VOID UpdateVdmMenu ( VOID  )

static

Definition at line 196 of file console.c.

{
    UpdateVdmMenuMouse();
    UpdateVdmMenuDisks();
}

Referenced by CreateVdmMenu().

UpdateVdmMenuDisks()

VOID UpdateVdmMenuDisks

(

VOID

)

Definition at line 146 of file console.c.

{
    UINT_PTR ItemID;
    USHORT i;
 
    WCHAR szNoMedia[100];
    WCHAR szMenuString1[256], szMenuString2[256];
 
    /* Update the disks menu items */
 
    LoadStringW(GetModuleHandle(NULL),
                IDS_NO_MEDIA,
                szNoMedia,
                ARRAYSIZE(szNoMedia));
 
    LoadStringW(GetModuleHandle(NULL),
                IDS_VDM_MOUNT_FLOPPY,
                szMenuString1,
                ARRAYSIZE(szMenuString1));
 
    for (i = 0; i < ARRAYSIZE(GlobalSettings.FloppyDisks); ++i)
    {
        ItemID = ID_VDM_DRIVES + (2 * i);
 
        if (GlobalSettings.FloppyDisks[i].Length != 0 &&
            GlobalSettings.FloppyDisks[i].Buffer      &&
           *GlobalSettings.FloppyDisks[i].Buffer != L'\0')
        {
            /* Update item text */
            _snwprintf(szMenuString2, ARRAYSIZE(szMenuString2), szMenuString1, i, GlobalSettings.FloppyDisks[i].Buffer);
            szMenuString2[ARRAYSIZE(szMenuString2) - 1] = UNICODE_NULL;
            ModifyMenuW(hConsoleMenu, ItemID, MF_BYCOMMAND | MF_STRING, ItemID, szMenuString2);
 
            /* Enable the eject item */
            EnableMenuItem(hConsoleMenu, ItemID + 1, MF_BYCOMMAND | MF_ENABLED);
        }
        else
        {
            /* Update item text */
            _snwprintf(szMenuString2, ARRAYSIZE(szMenuString2), szMenuString1, i, szNoMedia);
            szMenuString2[ARRAYSIZE(szMenuString2) - 1] = UNICODE_NULL;
            ModifyMenuW(hConsoleMenu, ItemID, MF_BYCOMMAND | MF_STRING, ItemID, szMenuString2);
 
            /* Disable the eject item */
            EnableMenuItem(hConsoleMenu, ItemID + 1, MF_BYCOMMAND | MF_GRAYED);
        }
    }
}

Referenced by EjectFloppy(), EmulatorInitialize(), MountFloppy(), and UpdateVdmMenu().

UpdateVdmMenuMouse()

static VOID UpdateVdmMenuMouse ( VOID  )

static

Definition at line 130 of file console.c.

{
    WCHAR szMenuString[256];
 
    /* Update "Capture/Release mouse" menu item */
    if (LoadStringW(GetModuleHandle(NULL),
                    (CaptureMouse ? IDS_RELEASE_MOUSE : IDS_CAPTURE_MOUSE),
                    szMenuString,
                    ARRAYSIZE(szMenuString)) > 0)
    {
        ModifyMenuW(hConsoleMenu, ID_CAPTURE_MOUSE,
                    MF_BYCOMMAND, ID_CAPTURE_MOUSE, szMenuString);
    }
}

Referenced by MenuEventHandler(), and UpdateVdmMenu().

VdmMenuExists()

static BOOL VdmMenuExists ( HMENU  hConsoleMenu )

static

Definition at line 111 of file console.c.

{
    INT MenuPos, i;
    MenuPos = GetMenuItemCount(hConsoleMenu);
 
    /* Check for the presence of one of the VDM menu items */
    for (i = 0; i <= MenuPos; i++)
    {
        if (GetMenuItemID(hConsoleMenu, i) == ID_CAPTURE_MOUSE)
        {
            /* Set VdmMenuPos to the position of the existing menu */
            VdmMenuPos = i - 1;
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by CreateVdmMenu().

VdmShutdown()

VOID VdmShutdown

(

BOOLEAN

Immediate

)

HACK!! HACK!!

Definition at line 317 of file ntvdm.c.

{
    /*
     * Immediate = TRUE:  Immediate shutdown;
     *             FALSE: Delayed shutdown.
     */
    static BOOLEAN MustShutdown = FALSE;
 
    /* If a shutdown is ongoing, just return */
    if (MustShutdown)
    {
        DPRINT1("Shutdown is ongoing...\n");
        Sleep(INFINITE);
        return;
    }
 
    /* First notify DOS to see whether we can shut down now */
    MustShutdown = DosShutdown(Immediate);
    /*
     * In case we perform an immediate shutdown, or the DOS says
     * we can shut down, do it now.
     */
    MustShutdown = MustShutdown || Immediate;
 
    if (MustShutdown)
    {
        EmulatorTerminate();
 
        BiosCleanup();
        EmulatorCleanup();
        ConsoleCleanup();
 
        FreeGlobalSettings(&GlobalSettings);
 
        DPRINT1("\n\n\nNTVDM - Exiting...\n\n\n");
        /* Some VDDs rely on the fact that NTVDM calls ExitProcess on Windows */
        ExitProcess(0);
    }
}

Referenced by ConsoleCtrlHandler(), MenuEventHandler(), and wmain().

Variable Documentation

CaptureMouse

BOOL CaptureMouse = FALSE

static

Definition at line 23 of file console.c.

Referenced by ConsoleCleanupUI(), ConsoleReattach(), FocusEventHandler(), MenuEventHandler(), and UpdateVdmMenuMouse().

ConsoleInput

HANDLE ConsoleInput = INVALID_HANDLE_VALUE

static

Definition at line 16 of file console.c.

ConsoleOutput

HANDLE ConsoleOutput = INVALID_HANDLE_VALUE

static

Definition at line 17 of file console.c.

Referenced by ConsoleAttach(), ConsoleCleanup(), ConsoleCleanupUI(), ConsoleDetach(), ConsoleInit(), ConsoleInitUI(), EmulatorInitialize(), and wmain().

CurrentConsoleOutput

HANDLE CurrentConsoleOutput = INVALID_HANDLE_VALUE

static

Definition at line 14 of file console.c.

Referenced by ConsoleReattach(), FocusEventHandler(), and MenuEventHandler().

hConsoleMenu

HMENU hConsoleMenu = NULL

static

Definition at line 21 of file console.c.

Referenced by CreateVdmMenu(), DestroyVdmMenu(), UpdateVdmMenuDisks(), UpdateVdmMenuMouse(), and VdmMenuExists().

hConsoleWnd

HWND hConsoleWnd = NULL

Definition at line 20 of file console.c.

Referenced by CaptureMousePointer(), ConsoleInitUI(), CreateVdmMenu(), DestroyVdmMenu(), DisplayMessage(), and MountFloppy().

OrgConsoleInputMode

DWORD OrgConsoleInputMode

static

Definition at line 18 of file console.c.

Referenced by ConsoleAttach(), and ConsoleDetach().

OrgConsoleOutputMode

DWORD OrgConsoleOutputMode

static

Definition at line 18 of file console.c.

Referenced by ConsoleAttach(), and ConsoleDetach().

VdmMainMenuItems

const VDM_MENUITEM VdmMainMenuItems[]

static

Initial value:

=
{
    { -1, NULL, 0 },    
    { IDS_CAPTURE_MOUSE, NULL, ID_CAPTURE_MOUSE },  
    { IDS_VDM_MENU , VdmMenuItems, 0 },             
 
    { 0, NULL, 0 }      
}

Definition at line 48 of file console.c.

Referenced by CreateVdmMenu(), and DestroyVdmMenu().

VdmMenuItems

const VDM_MENUITEM VdmMenuItems[]

static

Initial value:

=
{
    { IDS_VDM_DUMPMEM_TXT, NULL, ID_VDM_DUMPMEM_TXT },
    { IDS_VDM_DUMPMEM_BIN, NULL, ID_VDM_DUMPMEM_BIN },
    { -1, NULL, 0 },    
    
    
    { -1, NULL, 0 },    
    { IDS_VDM_QUIT       , NULL, ID_VDM_QUIT        },
 
    { 0, NULL, 0 }      
}

Definition at line 35 of file console.c.

VdmMenuPos

INT VdmMenuPos = -1

static

Definition at line 22 of file console.c.

Referenced by CreateVdmMenu(), DestroyVdmMenu(), and VdmMenuExists().