/****************************** Module Header ******************************\
* Module Name: timeout.c
*
* Copyright (c) 1991, Microsoft Corporation
*
* Support routines to implement dialog input timeouts
*
* History:
* 12-05-91 Davidc       Created.
\***************************************************************************/

#include "precomp.h"
#pragma hdrstop

//
// Define private notification message sent to dialogs on an interrupt
//

#define WM_DLG_INTERRUPT    (WM_USER+600)

//
// Define value returned by a message box or dialog box when interrupted
// This value must be interpreted using the InterrruptType variable
//

#define DLG_INTERRUPT 0 // Must be 0 so we can return it from message boxes

//
// Define the maximum number of nested dialogs we can handle
//

#define MAX_NESTED_TIMEOUTS 5
#define TIMEOUT_DEFAULT     120

//
// Globals - these will need to put in an instance data structure
// when we have multiple logon threads
//

//
// Define array used to store window handles who ask for timeout service.
// This array is used as a push down stack to suppport nested timeouts
//

HWND        hwndArray[MAX_NESTED_TIMEOUTS];
TIMEOUT     TimeoutArray[MAX_NESTED_TIMEOUTS];
PGLOBALS    GlobalsArray[MAX_NESTED_TIMEOUTS];
LONG        NestedIndex = 0;


//
// Variable that stores the required return code for the top dialog.
// This is only used if we force a dialog to return DLG_INTERRUPT.
// We have to use this mechanism because message boxes will not allow
// you to return any random value. DLG_INTERRUPT is 0 which message
// boxes let through.
//

int TopDialogReturnCode = DLG_INTERRUPT;



HWND        hwndMessageOwner = NULL;// Store the owner of the message box
                                    // we want to find
LPTSTR       TimeoutTitle = NULL;    // Stores the title of the message box we
                                    // are going to timeout on.
BOOL        InputHooksInstalled = FALSE;
BOOL        TimeoutOccurred = FALSE;
BOOL        DialogActive = FALSE;

//
// Variables that support the input timeout
//

int     TimerID = 0;
HHOOK   hhkMouse;
HHOOK   hhkKeyboard;


//
// Internal Prototypes
//

BOOL PushMessageTimeout(HWND hwndOwner, TIMEOUT TimeDelay, LPTSTR Title, PGLOBALS pGlobals);
BOOL PopMessageTimeout(VOID);
BOOL PushTimeout(HWND hwnd, TIMEOUT TimeDelay, PGLOBALS pGlobals);
BOOL PopTimeout(VOID);
BOOL StartTopTimeout(VOID);
HWND GetTopTimeout(PTIMEOUT pTimeDelay);
BOOL SetTopTimeout(HWND hwnd);
BOOL SetTimeout(TIMEOUT TimeDelay);
BOOL CheckTimeout(HWND hwnd);
BOOL SetInputHooks(VOID);
BOOL ReleaseInputHooks(VOID);
LRESULT WINAPI MouseHookfn(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT WINAPI KeyboardHookfn(int nCode, WPARAM wParam, LPARAM lParam);
BOOL StartTimer(TIMEOUT TimeDelay);
WORD WINAPI Timerfn(HWND hwnd, WORD Message, int IDEvent, DWORD dwTime);
BOOL StopTimer(VOID);
BOOL FindMessageBox(VOID);
BOOL WINAPI FindEnumfn(HWND, LPARAM);
TIMEOUT InheritTimeout(TIMEOUT TimeDelay);
BOOL HandleScreenSaverTimeout(HWND hwndTop, TIMEOUT Timeout);
BOOL HandleUserLogoff(PGLOBALS pGlobals, HWND hwndTop, TIMEOUT Timeout, LONG Flags);


/***************************************************************************\
* ForwardMessage
*
* Sends a message to the window on top of the timeout stack
*
* 12-05-91 Davidc       Created.
\***************************************************************************/
#if 0

LONG
ForwardMessage(
    PGLOBALS pGlobals,
    UINT    Message,
    WPARAM  wParam,
    LPARAM  lParam
    )
{
    TIMEOUT Timeout;
    HWND    hwndTop = GetTopTimeout(&Timeout);

    // If there is nothing on the stack, dump the message
    if (hwndTop == NULL) {
        DebugLog((DEB_ERROR, "No-one on the stack to forward message to !"));
        ASSERT(FALSE);
        return(0);
    }

    switch (Message) {

    case WM_SAS:
        SendMessage(hwndTop, Message, wParam, lParam);
        break;

    case WM_INPUT_TIMEOUT:

        // Check the timeout condition still exists and exit the dialog
        if (CheckTimeout(hwndTop)) {

            EndTopDialog(hwndTop, DLG_INPUT_TIMEOUT);

        }
        break;

    case WM_SCREEN_SAVER_TIMEOUT:

        //
        // Ignore if the current user doesn't have an enabled screen-saver.
        // The timeout notification may have been in the message queue when
        // we changed user - the new user may not have a screen-saver.
        //

        if (ScreenSaverEnabled(pGlobals)) {
            HandleScreenSaverTimeout(hwndTop, Timeout);
        }

        break;

    case WM_USER_LOGOFF:

        HandleUserLogoff(pGlobals, hwndTop, Timeout, lParam);

        break;

    default:
        DebugLog((DEB_ERROR, "Unexpected message supplied to ForwardMessage"));
        ASSERT(FALSE);
        break;
    }

    return(0);
}


/***************************************************************************\
* HandleScreenSaverTimeout
*
* Deal with a screen-saver timeout notification from windows.
*
* If the topmost window has a timeout, the screen-saver timeout simply
* interrupts the dialog and causes it to return DLG_SCREEN_SAVER_TIMEOUT.
*
* If the topmost window has no timeout, the window stack is searched from
* the top for the first window to have the TIMEOUT_SS_NOTIFY bit set.
* This window is then sent a WM_SCREEN_SAVER_TIMEOUT message.
* This allows a non-timeout window to take responsibility for starting
* the screen-saver from any-non timeout windows above it.
*
* Returns TRUE
*
* 12-05-91 Davidc       Created.
\***************************************************************************/
BOOL
HandleScreenSaverTimeout(
    HWND hwndTop,
    TIMEOUT Timeout
    )
{
    HWND hwndNotify;
    LONG Index;

    //
    // If top top window has a timeout, it should be interrupted
    //

    if (TIMEOUT_VALUE(Timeout) != TIMEOUT_NONE) {

        EndTopDialog(hwndTop, DLG_SCREEN_SAVER_TIMEOUT);

        return(TRUE); // We're done
    }


    //
    // The top window has no timeout, search for window with notify bit set
    //

    for (Index = NestedIndex - 1; Index >= 0; Index --) {
        if (TIMEOUT_NOTIFY(TimeoutArray[Index])) {
            // Found a window with the notify bit set
            break;
        }
    }

    // Q.A.
    ASSERTMSG("Notify window not found on timeout stack", Index >= 0);
    ASSERTMSG("Found notify window with a non-zero timeout !!",
               TIMEOUT_VALUE(TimeoutArray[Index]) == TIMEOUT_NONE);

    hwndNotify = hwndArray[Index];

    ASSERTMSG("Found notify window with a NULL hwnd !!", hwndNotify != NULL);

    //
    // Forward the message to the notify window
    //

    SendMessage(hwndNotify, WM_SCREEN_SAVER_TIMEOUT, 0, 0);

    return(TRUE);   // We've dealt with it
}

#endif

/***************************************************************************\
* MapResultCode
*
* Maps the DLG_INTERRUPT message to the appropriate return code stored
* in TopDialogReturnCode
*
* 03-17-92 Davidc       Created.
\***************************************************************************/

int
MapResultCode(
    int Result,
    int TopDialogReturnCode
    )
{
    if (Result == DLG_INTERRUPT) {

        ASSERT(TopDialogReturnCode != DLG_INTERRUPT);

        Result = TopDialogReturnCode;

#if DBG
        //
        // Reset the stored return code so we can detect if an interrupt is
        // generated without the code being set correctly.
        //

        TopDialogReturnCode = DLG_INTERRUPT;
#endif
    }

    if (Result == -1) {
        DebugLog((DEB_ERROR, "Failed to create dialog or message box"));
    }

    return(Result);
}


/***************************************************************************\
* ProcessDialogTimeout
*
* Called as first part of dialog routine that wants to timeout after
* there is no input for a specified time. Simply sets up the hwnd on top
* of our stack.
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

VOID ProcessDialogTimeout(
    HWND    hwnd,
    UINT    Message,
    DWORD   wParam,
    LONG    lParam)
{
    switch (Message) {

    case WM_INITDIALOG:
        if (!SetTopTimeout(hwnd)) {
            DebugLog((DEB_ERROR, "ProcessDialogTimeout failed to set the hwnd on top of the timeout stack"));
        }
    }
    DBG_UNREFERENCED_PARAMETER(Message);
    DBG_UNREFERENCED_PARAMETER(wParam);
    DBG_UNREFERENCED_PARAMETER(lParam);
}


/***************************************************************************\
* PushDialogTimeout
*
* Sets up an input timeout for the dialog box that is just about to be created
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL PushDialogTimeout(
    TIMEOUT    TimeDelay,
    PGLOBALS    pGlobals)
{
    TimeDelay = InheritTimeout(TimeDelay);

    // Push the timeout with a NULL hwnd (to be filled in later)
    PushTimeout(NULL, TimeDelay, pGlobals);


    return(TRUE);
}


/***************************************************************************\
* PushMessageTimeout
*
* Sets up an input timeout for the message box that is just about to be created
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL PushMessageTimeout(
    HWND    hwndOwner,
    TIMEOUT TimeDelay,
    LPTSTR   Title,
    PGLOBALS    pGlobals)
{
    TimeDelay = InheritTimeout(TimeDelay);

    // Check the last message box has been dealt with
    ASSERTMSG("Last timeout message box not identified yet !", TimeoutTitle == NULL);

    // Push the timeout with a NULL hwnd (to be filled in later)
    PushTimeout(NULL, TimeDelay, pGlobals);

    // Store the message box title so that when we need to operate on the
    // message box, we can go and search for it by title.

    TimeoutTitle = Title;
    hwndMessageOwner = hwndOwner;
    DialogActive = TRUE;

    return(TRUE);
}


/***************************************************************************\
* PopMessageTimeout
*
* Pops the top timeout from the stack and reenables the timeout for the
* next guy on the stack
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL PopMessageTimeout(VOID)
{
    PopTimeout();

    // Reset our global in case we never went off to search for the
    // message box 'cos we never had to

    TimeoutTitle = NULL;
    DialogActive = FALSE;

    return(TRUE);
}


/***************************************************************************\
* FindMessageBox
*
* Searches for the message box that our globals tell us we're looking for.
*
* Returns TRUE if found, otherwise FALSE
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL FindMessageBox(VOID)
{
    BOOL Found;

    Found = !EnumTaskWindows(GetCurrentThreadId(), FindEnumfn, 0);

    if (!Found) {
        DebugLog((DEB_ERROR, "Message box window <%s> not found !!!", TimeoutTitle));
    }

    return(Found);
}


/***************************************************************************\
* FindEnumfn
*
* Enumeration function used by FindMessageBox()
*
* Returns FALSE if message box is found, otherwise TRUE
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL WINAPI
FindEnumfn(
    HWND    hwnd,
    LPARAM  lParam)
{
    TCHAR    Title[MAX_STRING_BYTES];

    // See if this hwnd is the one

    GetWindowText(hwnd, Title, sizeof(Title));

    if (lstrcmp(Title, TimeoutTitle) == 0) {

        // Found it

        if (!SetTopTimeout(hwnd)) {
            DebugLog((DEB_ERROR, "failed to set top timeout for message box !!"));
        }

        // Reset our global
        TimeoutTitle = NULL;

        return(FALSE);  // Stop enumeration
    }

    return(TRUE);   // Continue enumeration

    DBG_UNREFERENCED_PARAMETER(lParam);
}


/***************************************************************************\
* InheritTimeout
*
* Converts a timedelay value that is potentially TIMEOUT_CURRENT to
* an independent timedelay value.
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

TIMEOUT InheritTimeout(
    TIMEOUT TimeDelay
    )
{
    TIMEOUT ResultantTimeDelay;

    if (TIMEOUT_VALUE(TimeDelay) == TIMEOUT_CURRENT) {
        //
        // Inherit timedelay from previous window
        //
        HWND hwndTop = GetTopTimeout(&ResultantTimeDelay);

        if (!hwndTop)
        {
            DebugLog((DEB_WARN, "Tried to use TIMEOUT_CURRENT with no current timeout\n"));
            ResultantTimeDelay = TIMEOUT_DEFAULT;
        }

        // Don't inherit the TIMEOUT_SS_NOTIFY bit
        ResultantTimeDelay &= TIMEOUT_VALUE_MASK;

        // Set the notify bit to match the one passed in
        ResultantTimeDelay |= TIMEOUT_NOTIFY(TimeDelay);

    } else {
        //
        // No inheritance
        //
        ResultantTimeDelay = TimeDelay;
    }

    return(ResultantTimeDelay);
}


/***************************************************************************\
* PushTimeout
*
* Internal routine to push the timeout information onto a stack
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL PushTimeout(
    HWND    hwnd,
    TIMEOUT    TimeDelay,
    PGLOBALS    pGlobals)
{
    // Check we don't have an outstanding unidentified message box
    ASSERTMSG("Last timeout message box not identified yet !", TimeoutTitle == NULL);

    if (NestedIndex < MAX_NESTED_TIMEOUTS) {

#if DBG
        // Check we never push a TIMEOUT_NONE dialog when there's
        // a timeout window already on the stack.
        // This would be unusual.

        if (TIMEOUT_VALUE(TimeDelay) == TIMEOUT_NONE) {
            if (NestedIndex > 0) {
                if (TIMEOUT_VALUE(TimeoutArray[NestedIndex-1]) != TIMEOUT_NONE) {
                    ASSERTMSG("Non-timeout window pushed on top of timeout window !!!", FALSE);
                }
            }
        }
#endif
        hwndArray[NestedIndex] = hwnd;
        GlobalsArray[NestedIndex] = pGlobals;
        TimeoutArray[NestedIndex++] = TimeDelay;

        StartTopTimeout();

        return(TRUE);

    } else {

        DebugLog((DEB_ERROR, "PushTimeout - Out of input timeout slots !!"));
        return(FALSE);
    }

}


/***************************************************************************\
* PopTimeout
*
* Pops the top timeout from the stack and reenables the timeout for the
* next guy on the stack
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL PopTimeout(VOID)
{
    if (NestedIndex <= 0) {
        DebugLog((DEB_ERROR, "PopTimeout called with an empty timeout stack !!"));
        return(FALSE);
    }

    NestedIndex --;

    // This call will disable timeouts on an empty stack
    StartTopTimeout();

    return(TRUE);
}


/***************************************************************************\
* StartTopTimeout
*
* Starts (or restarts) the timeout on the top of the stack.
* If the stack is empty, timeouts are disabled.
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL StartTopTimeout(VOID)
{
    TIMEOUT    TimeDelay;

    if (NestedIndex > 0) {
        TimeDelay = TimeoutArray[NestedIndex - 1];
        DebugLog((DEB_TRACE_TIMEOUT, "Enabling timeout after %d seconds\n", TIMEOUT_VALUE(TimeDelay)));
    } else {
        DebugLog((DEB_TRACE_TIMEOUT, "Disabling timeouts\n"));
        TimeDelay = TIMEOUT_NONE;   // Disable timeouts
    }

    SetTimeout(TIMEOUT_VALUE(TimeDelay));

    return(TRUE);
}


/***************************************************************************\
* GetTopTimeout
*
* Returns the timeout on the top of the stack.
*
* Returns top hwnd and time-delay or NULL on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

HWND GetTopTimeout(
    PTIMEOUT   pTimeDelay)
{
    HWND    hwndTop = NULL;
    TIMEOUT TimeDelay = 0;

    if (TimeoutTitle != NULL) {
        // Go search for message box before getting the top hwnd
        FindMessageBox();
    }

    if (NestedIndex > 0) {
        hwndTop = hwndArray[NestedIndex - 1];
        TimeDelay = TimeoutArray[NestedIndex - 1];
    }

    if (pTimeDelay != NULL) {
        *pTimeDelay = TimeDelay;
    }

    return(hwndTop);
}

//+---------------------------------------------------------------------------
//
//  Function:   TimeoutUpdateTopTimeout
//
//  Synopsis:   Updates the current timeout, returns FALSE if no window
//              active, TRUE if it was updated.
//
//  Arguments:  [Timeout] --
//
//  History:    3-05-96   RichardW   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
BOOL
TimeoutUpdateTopTimeout(
    DWORD   Timeout)
{
    if ( DialogActive )
    {
        if ( TimeoutTitle != NULL )
        {
            FindMessageBox();
        }

        if ( NestedIndex > 0 )
        {
            TimeoutArray[ NestedIndex - 1 ] = Timeout;
            return( TRUE );
        }

    }

    return( FALSE );
}



/***************************************************************************\
* SetTopTimeout
*
* Sets the hwnd on top of the timeout stack to the one specified.
* The top timeout value is left unchanged.
*
* Checks if the existing hwnd is NULL, if not this call fails.
*
* Returns TRUE on success, FALSE on failure.
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL SetTopTimeout(
    HWND    hwnd)
{
    if (NestedIndex <= 0) {
        DebugLog((DEB_ERROR, "SetTopTimeout : Tried to set the top hwnd on an empty stack !!"));
        return(FALSE);
    }

    if (hwndArray[NestedIndex - 1] != NULL) {
        DebugLog((DEB_ERROR, "SetTopTimeout : hwnd at top of stack is not NULL !!"));
        return(FALSE);
    }

    hwndArray[NestedIndex - 1] = hwnd;

    return(TRUE);
}


/***************************************************************************\
* SetTimeout
*
* Sets an input timeout for the specified window using the specified delay.
*
* If TimeDelay = 0, no timeout is enabled for this window.
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL SetTimeout(
    TIMEOUT    TimeDelay)
{
    if (TimeDelay != 0) {

        if (!InputHooksInstalled) {
            SetInputHooks();
        }
        StartTimer(TimeDelay);

    } else {

        if (InputHooksInstalled) {
            ReleaseInputHooks();
        }

        StopTimer();
    }

    return (TRUE);
}


/***************************************************************************\
* CheckTimeout
*
* Returns TRUE if a timeout is still occurring for this window, otherwise FALSE
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL CheckTimeout(
    HWND    hwnd)
{
    if (GetTopTimeout(NULL) != hwnd) {
        return(FALSE);
    }

    return (TimeoutOccurred);
}


/***************************************************************************\
* StartTimer
*
* Starts (or restarts) the input timer with the specified delay
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL StartTimer(
    TIMEOUT    TimeDelay)
{
    StopTimer();

    TimerID = SetTimer(NULL, TimerID, TimeDelay * 1000, (TIMERPROC)Timerfn);

    return(TimerID != 0);
}


/***************************************************************************\
* StopTimer
*
* Stops the input timer and resets the timeout flag
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL StopTimer(VOID)
{
    if (TimerID != 0) {
        KillTimer(NULL, TimerID);
        TimerID = 0;
    }

    TimeoutOccurred = FALSE;

    return(TRUE);
}


/***************************************************************************\
* Timerfn
*
* Called when the timer goes off.
*
* 12-05-91 Davidc       Created.
\***************************************************************************/
WORD WINAPI Timerfn(
    HWND    hwnd,
    WORD    Message,
    int     IDEvent,
    DWORD   dwTime)
{
    // Set the timeout flag and stop any more timeouts

    TimeoutOccurred = TRUE;

    KillTimer(NULL, TimerID);
    TimerID = 0;

    if (GetTopTimeout(NULL) == NULL) {
        DebugLog((DEB_ERROR, "Input timer went off, but top timeout has NULL hwnd"));
    }

    // Send a message to the window who owns the timeout
    // ForwardMessage(NULL, WM_INPUT_TIMEOUT, FALSE, 0);

    DebugLog((DEB_TRACE_TIMEOUT, "Input timer went off, sending TIMEOUT\n"));
    if (DialogActive)
    {
        EndTopDialog(NULL, WLX_DLG_INPUT_TIMEOUT);
    }
    else
        SASRouter(GlobalsArray[NestedIndex - 1], WLX_SAS_TYPE_TIMEOUT);

    return(0);

    DBG_UNREFERENCED_PARAMETER(hwnd);
    DBG_UNREFERENCED_PARAMETER(Message);
    DBG_UNREFERENCED_PARAMETER(IDEvent);
    DBG_UNREFERENCED_PARAMETER(dwTime);
}


/***************************************************************************\
* SetInputHooks
*
* Installs input hooks
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL SetInputHooks(VOID)
{
    InputHooksInstalled = TRUE;


    hhkMouse = SetWindowsHook(WH_MOUSE, MouseHookfn);
    hhkKeyboard = SetWindowsHook(WH_KEYBOARD, KeyboardHookfn);

    return(TRUE);
}


/***************************************************************************\
* ReleaseInputHooks
*
* Uninstalls input hooks
*
* Returns TRUE on success, FALSE on failure
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL ReleaseInputHooks(VOID)
{
    UnhookWindowsHook(WH_MOUSE, MouseHookfn);
    UnhookWindowsHook(WH_KEYBOARD, KeyboardHookfn);

    InputHooksInstalled = FALSE;

    return(TRUE);
}


/***************************************************************************\
* MouseHookfn
*
* Called when there is mouse input for this app
*
* 12-05-91 Davidc       Created.
\***************************************************************************/
LRESULT WINAPI
MouseHookfn(
    int nCode,
    WPARAM wParam,
    LPARAM lParam
    )
{
    if (nCode >= 0) {
        if (!TimeoutOccurred) {
            StartTopTimeout();
        }
    }

    return(DefHookProc(nCode, wParam, lParam, &hhkMouse));
}


/***************************************************************************\
* KeyboardHookfn
*
* Called when there is keyboard input for this app
*
* 12-05-91 Davidc       Created.
\***************************************************************************/
LRESULT WINAPI
KeyboardHookfn(
    int nCode,
    WPARAM wParam,
    LPARAM lParam
    )
{
    if (nCode >= 0) {
        if (!TimeoutOccurred) {
            StartTopTimeout();
        }
    }

    return(DefHookProc(nCode, wParam, lParam, &hhkKeyboard));
}


/***************************************************************************\
* TimeoutMessageBox
*
* Same as a normal message box, but times out if there is no user input
* for the specified number of seconds
* For convenience, this api takes string resource ids rather than string
* pointers as input. The resources are loaded from the .exe module
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

int TimeoutMessageBoxEx(
    PGLOBALS pGlobals,
    HWND hwnd,
    UINT IdText,
    UINT IdCaption,
    UINT wType,
    TIMEOUT Timeout)
{
    TCHAR    CaptionBuffer[MAX_STRING_BYTES];
    PTCHAR   Caption = CaptionBuffer;
    TCHAR    Text[MAX_STRING_BYTES];

    LoadString(NULL, IdText, Text, MAX_STRING_LENGTH);

    if (IdCaption != 0) {
        LoadString(NULL, IdCaption, Caption, MAX_STRING_LENGTH);
    } else {
        Caption = NULL;
    }

    return TimeoutMessageBoxlpstr(pGlobals, hwnd, Text, Caption, wType, Timeout);
}


/***************************************************************************\
* TimeoutMessageBoxlpstr
*
* Same as a normal message box, but times out if there is no user input
* for the specified number of seconds
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

int TimeoutMessageBoxlpstr(
    PGLOBALS pGlobals,
    HWND hwnd,
    LPTSTR Text,
    LPTSTR Caption,
    UINT wType,
    TIMEOUT Timeout)
{
    int     Result;
    int DlgResult;

#if DBG
    //
    // Reset the return code so if we forget to set if before returning
    // an interrupt MapResultCode will detect it.
    // Also this allows us to check the interrupt type is not overwritten
    // by a second interrupt before we clear it.
    //
    TopDialogReturnCode = DLG_INTERRUPT;
#endif

    // Set up input timeout
    PushMessageTimeout(hwnd, Timeout, Caption, pGlobals);

    Result = MessageBox(hwnd, Text, Caption, wType);

    // Re-enable previous timeout
    PopMessageTimeout();

    DlgResult = MapResultCode(Result, TopDialogReturnCode);

#if DBG
    //
    // Reset the stored return code so we can detect if an interrupt is
    // generated without the code being set.
    //

    TopDialogReturnCode = DLG_INTERRUPT;
#endif

    return(DlgResult);
}


/***************************************************************************\
* TimeoutDialogBoxParam
*
* Same as a normal dialog box, but times out if there is no user input
* for the specified number of seconds
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

int
TimeoutDialogBoxParam(
    PGLOBALS pGlobals,
    HANDLE hInstance,
    LPTSTR lpTemplateName,
    HWND hwndParent,
    DLGPROC lpDialogFunc,
    LONG dwInitParam,
    TIMEOUT Timeout)
{
    int Result;
    MSG msg;

#if DBG
    //
    // Reset the return code so if we forget to set if before returning
    // an interrupt MapResultCode will detect it.
    // Also this allows us to check the interrupt type is not overwritten
    // by a second interrupt before we clear it.
    //
    TopDialogReturnCode = DLG_INTERRUPT;
#endif

    while (TRUE) {
        PushDialogTimeout(Timeout, pGlobals);

        Result = DialogBoxParam(hInstance,
                                lpTemplateName,
                                hwndParent,
                                lpDialogFunc,
                                dwInitParam
                                );
#if DBG
        if (Result < 0)
        {
            if ((DWORD) lpTemplateName > 0x00010000)
            {
                DebugLog((DEB_WARN, "DialogBoxParam(%#x, %ws, %#x, %#x, %#x) failed, error %d\n",
                            hInstance, lpTemplateName, hwndParent, lpDialogFunc,
                            dwInitParam, GetLastError() ));
            }
            else
            {
                DebugLog((DEB_WARN, "DialogBoxParam(%#x, %#x, %#x, %#x, %#x) failed, error %d\n",
                            hInstance, lpTemplateName, hwndParent, lpDialogFunc,
                            dwInitParam, GetLastError() ));

            }
        }
#endif

        // Re-enable previous timeout
        PopTimeout();

        //
        // If the dialog returned due to WM_QUIT, eat the message
        // and do the dialog again.
        //

        if (!PeekMessage(&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE)) {
            break;
        }
    }

    return(Result);
}


/***************************************************************************\
* TimeoutDialogBoxIndirectParam
*
* Same as a normal dialog box, but times out if there is no user input
* for the specified number of seconds
*
* 05-15-92 Davidc       Created.
\***************************************************************************/

int
TimeoutDialogBoxIndirectParam(
    PGLOBALS pGlobals,
    HANDLE hInstance,
    LPDLGTEMPLATE Template,
    HWND hwndParent,
    DLGPROC lpDialogFunc,
    LONG dwInitParam,
    TIMEOUT Timeout)
{
    int Result;
    MSG msg;


    while (TRUE) {
        PushDialogTimeout(Timeout, pGlobals);

        Result = DialogBoxIndirectParam(hInstance,
                                        Template,
                                        hwndParent,
                                        lpDialogFunc,
                                        dwInitParam
                                        );

        // Re-enable previous timeout
        PopTimeout();

        //
        // If the dialog returned due to WM_QUIT, eat the message
        // and do the dialog again.
        //

        if (!PeekMessage(&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE)) {
            break;
        }
    }

    return(Result);
}



/***************************************************************************\
* EndTopDialog
*
* Interrupts the dialog on top of the timeout stack and causes it to return
* the code specified.
*
* The passed hwnd is that of the caller. This is not used other than as
* a debugging aid.
*
* The dlgresult passed must be one of the interrupt types.
*
* Returns TRUE on success, FALSE on failure.
*
* 12-05-91 Davidc       Created.
\***************************************************************************/

BOOL EndTopDialog(
    HWND    hwnd,
    int DlgResult
    )
{
    HWND    hwndTop = GetTopTimeout(NULL);

    if (hwndTop == NULL) {
        DebugLog((DEB_ERROR, "EndTopDialog called with no dialogs on the stack!"));
        ASSERT(FALSE);
        return(FALSE);
    }

#ifdef WINLOGON_TEST
    if (hwndTop != hwnd) {
        DebugLog((DEB_ERROR, "Ending top dialog from lower-level dialog!"));
    }
#endif

    //
    // Check the value has not already been set
    //

    ASSERT(TopDialogReturnCode == DLG_INTERRUPT);

    TopDialogReturnCode = DlgResult;

    return (EndDialog(hwndTop, DLG_INTERRUPT));
}

BOOL
KillMessageBox( DWORD SasCode )
{
    DWORD   EndCode;

    //
    // This will kill any outstanding message boxes due to an incoming
    // SAS event.  This is used by SendSasToTopWindow when it is forwarding
    // along an GINA specific SAS.  This kills pending message boxes so that
    // the dialog regains control.
    //

    if (DialogActive)
    {
        switch ( SasCode )
        {
            case WLX_SAS_TYPE_TIMEOUT:
                EndCode = WLX_DLG_INPUT_TIMEOUT ;
                break;

            case WLX_SAS_TYPE_SCRNSVR_TIMEOUT:
                EndCode = WLX_DLG_SCREEN_SAVER_TIMEOUT ;
                break;

            default:
                EndCode = WLX_DLG_SAS;
                break;
        }

        EndTopDialog(NULL, EndCode);
        return(TRUE);
    }
    return(FALSE);
}