windows-server-2003/windows/advcore/gdiplus/engine/entry/dispnotify.cpp

/**************************************************************************\
* 
* Copyright (c) 1998-1999  Microsoft Corporation
*
* Abstract:
*
*  Display/Palette notification routines for GDI+.
*
* Revision History:
*
*   7/19/99 ericvan
*       Created it.
*   9/15/2000 agodfrey
*       #175866: Improved GDI+ startup, shutdown and event notification
*
\**************************************************************************/

#include "precomp.hpp"

#include "..\render\vgahash.hpp"

#include <winuser.h>

VOID DisplayNotify();
VOID PaletteNotify();
VOID SysColorNotify();

/////////////////////////////// MESSAGE HANDLERS ///////////////////////////////

/**************************************************************************\
*
* Function Description:
*
*   This routine receives a display notification request and appropriately
*   readjusts the size and resolution of DCI screen surface.
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*
\**************************************************************************/

VOID DisplayNotify()
{
    GpDevice *device = Globals::DesktopDevice;

    Devlock devlock(device);

    // Check to see if we have switched to a Terminal Server Session
    if (GetSystemMetrics(SM_REMOTESESSION))
    {
        // it is a remote session
        Globals::IsTerminalServer = TRUE;
    }
    else
    {
        // it isn't a remote session.
        Globals::IsTerminalServer = FALSE;
    }

    
    Globals::DesktopDriver->DesktopChangeNotification();

    DWORD width, height;

    width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    height = GetSystemMetrics(SM_CYVIRTUALSCREEN);

    if ((device != NULL) &&
        (device->DeviceHdc != NULL) &&
        (GetDeviceCaps(device->DeviceHdc, BITSPIXEL) <= 8))
    {
        // <SystemPalette>
        
        if (device->Palette == NULL) 
        {
            device->Palette = (ColorPalette*)GpMalloc(sizeof(ColorPalette)
                                                      + sizeof(ARGB) * 256);
            if (device->Palette == NULL)
            {
                return;
            }
        }
       
        INT           numEntries;
        PALETTEENTRY  palentry[256];
        RGBQUAD       rgb[256];
        ColorPalette* palette;

        palette = device->Palette;

        // [agodfrey] On Win9x, GetSystemPaletteEntries(hdc, 0, 256, NULL) 
        //    doesn't do what MSDN says it does. It seems to return the number
        //    of entries in the logical palette of the DC instead. So we have
        //    to make it up ourselves.
        
        numEntries = (1 << (GetDeviceCaps(device->DeviceHdc, BITSPIXEL) *
                            GetDeviceCaps(device->DeviceHdc, PLANES)));

        GetSystemPaletteEntries(device->DeviceHdc, 0, 256, &palentry[0]);

        palette->Count = numEntries;
        
        for (INT i=0; i<numEntries; i++) 
        {
            palette->Entries[i] = GpColor::MakeARGB(0xFF,
                                                    palentry[i].peRed,
                                                    palentry[i].peGreen,
                                                    palentry[i].peBlue);
            rgb[i].rgbRed = palentry[i].peRed;
            rgb[i].rgbGreen = palentry[i].peGreen;
            rgb[i].rgbBlue = palentry[i].peBlue;
            rgb[i].rgbReserved = 0;
        }
    
        if (device->DIBSectionBitmap != NULL) 
        {
            SetDIBColorTable(device->DIBSectionHdc, 0, numEntries, &rgb[0]);
        }

        Globals::PaletteChangeCount++;
    }

    // Set BufferWidth to 0.  This forces ::Start() to recreate the temporary
    // BufferDIB at the correct bit depth next time we process any cached records.

    // This needs to be done especially if the screen mode is not palettized
    // any more since the BufferDIB shouldn't be 8bpp, but reformatted to 32bpp.
    
    device->BufferWidth = 0;

    // Recreate the DCI object.  If the allocation fails, keep the old one
    // so that we don't access violate 'ScanDci' (although we might quite
    // happily draw wrong):

    EpScanGdiDci *scanDci = new EpScanGdiDci(Globals::DesktopDevice, TRUE);
    if (scanDci != NULL)
    {
        delete Globals::DesktopDevice->ScanDci;
        Globals::DesktopDevice->ScanDci = scanDci;
    }
    
    // update width and height on desktop surface
    // this copies the Device ScanDCI to Screen bitmap.

    Globals::DesktopSurface->InitializeForGdiScreen(
        Globals::DesktopDevice,
        width,
        height
    );
    
    // Give the driver an opportunity to adjust the surface.
    
    Globals::DesktopDriver->UpdateSurfacePixelFormat(
        Globals::DesktopSurface
    );
}

/**************************************************************************\
*
* Function Description:
*
*   This routine receives a palette change notification request and appropriately
*   readjusts the system palette matching.
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*
\**************************************************************************/

VOID PaletteNotify()
{
    Devlock devlock(Globals::DesktopDevice);

    // update count to force lazy recomputation of translation vector
    Globals::PaletteChangeCount++;

    // update the system palette 
    Globals::DesktopDriver->PaletteChangeNotification();
}

/**************************************************************************\
*
* Function Description:
*
*   This routine receives a WM_SYSCOLORCHANGE notifications and updates the
*   system magic colors.
*
* History:
*
*   1/10/2K ericvan
*       Created it.
*
\**************************************************************************/

VOID SysColorNotify()
{
    // [ericvan] There is no synchronization here.  If a synchronization 
    // problem should occur, the worst side effect would be a bad
    // color which would go away on a repaint.  I think we can live with it.

    Globals::SystemColors[16] = ::GetSysColor(COLOR_3DSHADOW);
    Globals::SystemColors[17] = ::GetSysColor(COLOR_3DFACE);
    Globals::SystemColors[18] = ::GetSysColor(COLOR_3DHIGHLIGHT);
    Globals::SystemColors[19] = ::GetSysColor(COLOR_DESKTOP);
    
    VGAHashRebuildTable(&Globals::SystemColors[16]);
}

////////////////////////// MESSAGE/WINEVENT CALLBACKS //////////////////////////

/**************************************************************************\
*
* Function Description:
*
*   This routine is the GDI+ hidden window message pump.  If the app doesn't
*   hook us directly, then we add a top-level window to intercept
*   WM_DISPLAYCHANGE and WM_PALETTECHANGED directly.
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*
\**************************************************************************/

LRESULT 
CALLBACK
NotificationWndProc(
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam
    )
{
   switch (uMsg) 
   {
   case WM_DISPLAYCHANGE:
      DisplayNotify();
      break;

   case WM_PALETTECHANGED:
      PaletteNotify();
      break;

   case WM_SYSCOLORCHANGE:
      SysColorNotify();
      break;

   case WM_WININICHANGE:
      if(lParam != 0 &&
         lstrcmpiA((LPCSTR)(lParam), "intl") == 0)
      {
          Globals::UserDigitSubstituteInvalid = TRUE;
      } else if ((wParam == SPI_SETFONTSMOOTHING) || (wParam == SPI_SETFONTSMOOTHINGTYPE) ||
          (wParam == SPI_SETFONTSMOOTHINGCONTRAST) || (wParam == SPI_SETFONTSMOOTHINGORIENTATION))
      {
          Globals::CurrentSystemRenderingHintInvalid  = TRUE;
      }
      break;
      
   default:
       if (Globals::g_nAccessibilityMessage == uMsg && uMsg >= WM_USER)
       {
            Globals::g_fAccessibilityPresent = TRUE;
       }
       else
       {
           return DefWindowProcA(hwnd, uMsg, wParam, lParam);
       }
   }

   // return 0 if we processed it.
   return 0;
}

/**************************************************************************\
*
* Function Description:
*
*   This routine is the GDI+ win-event hook.  It watches for full-drag
*   messages, to let the DCI renderer know when full-drag is being done.
*
* History:
*
*   3/21/2000 andrewgo
*       Created it.
*
\**************************************************************************/

VOID
CALLBACK
WinEventProcedure(
    HWINEVENTHOOK hWinEventHook,
    DWORD         event,
    HWND          hwnd,
    LONG          idObject,
    LONG          idChild,
    DWORD         idEventThread,
    DWORD         dwmsEventTime
    )
{
    ASSERT((event == EVENT_SYSTEM_MOVESIZESTART) ||
           (event == EVENT_SYSTEM_MOVESIZEEND));

    Globals::IsMoveSizeActive = (event == EVENT_SYSTEM_MOVESIZESTART);
}

/////////////////////// MESSAGE/WINEVENT INITIALIZATION ////////////////////////

VOID InternalNotificationShutdown();

/**************************************************************************\
*
* Function Description:
*
*   Called by NotificationStartup and BackgroundThreadProc.
*   Initializes the hidden window and WinEvent hook.
*
* Preconditions:
*
*   BackgroundThreadCriticalSection must be held.
*
* History:
*
*   9/15/2000 agodfrey
*       Created it.
*
\**************************************************************************/

BOOL
InternalNotificationStartup()
{
    // register a window class
    // we force ANSI rep using GDI+ for benefit of Win9x

    WNDCLASSA wndClass =
    {   
        0,
        &NotificationWndProc,
        0,
        0,
        DllInstance,
        NULL,
        NULL,
        NULL,
        "GDI+ Hook Window",
        "GDI+ Hook Window Class",
    };
    
    Globals::WindowClassAtom = RegisterClassA(&wndClass);

    if (!Globals::WindowClassAtom)
    {
        WARNING(("RegisterClass failed"));
        return FALSE;
    }
    
    // If this fails, we continue.  It just means we won't work properly
    // with accessibility software.
    
    Globals::g_nAccessibilityMessage =
        RegisterWindowMessageA("GDI+ Accessibility");
    
    Globals::HwndNotify = CreateWindowA((LPCSTR) Globals::WindowClassAtom,
                                        (LPCSTR) "GDI+ Window",
                                        WS_OVERLAPPED | WS_POPUP | WS_MINIMIZE,
                                        0,
                                        0,
                                        1,
                                        1,         // x,y,width,height
                                        NULL,      // hWndParent
                                        NULL,      // hMenu
                                        DllInstance,
                                        NULL);
    
    if (!Globals::HwndNotify) 
    {
        WARNING(("CreateWindowA failed, the GDI+ hook window does not exist!"));
        InternalNotificationShutdown();
        return FALSE;
    }

    // [ericvan] This is BS, but must be done.  We only receive palette 
    // messages if we have called SelectPalette at least once on our primary DC.
    
    {
        struct {
            LOGPALETTE logpal;
            PALETTEENTRY palEntry[256];
        } lp;
        
        const ColorPalette* colorPal = GetDefaultColorPalette(PIXFMT_8BPP_INDEXED);
        
        lp.logpal.palVersion = 0x300;
        lp.logpal.palNumEntries = static_cast<WORD>(colorPal->Count);
        
        for (INT i=0; i<lp.logpal.palNumEntries; i++)
        {
            GpColor color(colorPal->Entries[i]);
        
            lp.logpal.palPalEntry[i].peRed = color.GetRed();
            lp.logpal.palPalEntry[i].peGreen = color.GetGreen();
            lp.logpal.palPalEntry[i].peBlue = color.GetBlue();
            lp.logpal.palPalEntry[i].peFlags = 0;
        }
        
        HPALETTE hPal = CreatePalette(&lp.logpal);
        HDC hdc = GetDC(Globals::HwndNotify);
        SelectPalette(hdc, hPal, FALSE);
        ReleaseDC(Globals::HwndNotify, hdc);
        DeleteObject(hPal);
    }
    
    // [andrewgo] On NT, if a DCI lock is held while a window moves, NT is 
    // forced to redraw the whole screen.  If "Show window contents while 
    // dragging" (AKA "Full-drag") is enabled (it's on by default), 
    // then this can result in repeated, excessive repaints 
    // of the whole screen while somone is dragging a window around.
    //
    // We work around this by disabling DCI rendering while we notice
    // that window moves are happening.  
    
    if ((Globals::IsNt) && (Globals::SetWinEventHookFunction))
    {
        Globals::WinEventHandle = 
            (Globals::SetWinEventHookFunction)(EVENT_SYSTEM_MOVESIZESTART,
                                               EVENT_SYSTEM_MOVESIZEEND,
                                               NULL,
                                               WinEventProcedure,
                                               0,
                                               0,
                                               WINEVENT_OUTOFCONTEXT);
    
        ASSERT(Globals::WinEventHandle != NULL);

        if (!Globals::WinEventHandle)
        {
            InternalNotificationShutdown();
            return FALSE;
        }
    }
    
    return TRUE;
}

/**************************************************************************\
*
* Function Description:
*
*   Called by NotificationStartup and BackgroundThreadProc.
*   (Also by InternalNotificationStartup, to clean up when there's an 
*   error.)
*
*   Destroys the hidden window and WinEvent hook.
*
*   Keep this synchronized with SimulateInternalNotificationShutdown.
*
* Preconditions:
*
*   BackgroundThreadSection must be held.
*
* History:
*
*   9/15/2000 agodfrey
*       Created it.
*
\**************************************************************************/

VOID
InternalNotificationShutdown()
{
    if (Globals::UnhookWinEventFunction && Globals::WinEventHandle)
    {
        (Globals::UnhookWinEventFunction)(Globals::WinEventHandle);
        Globals::WinEventHandle = NULL;
    }
    
    if (Globals::HwndNotify) 
    {
        if (Globals::IsNt && (Globals::OsVer.dwMajorVersion == 4))
        {
            // NT 4.0 has a problem in its DestroyWindow that will
            // leave the application in a zombie state. 
            // Leak the window and rely on process cleanup.
        }
        else
        {
            DestroyWindow(Globals::HwndNotify);
        }
        Globals::HwndNotify = NULL;
    }
    
    if (Globals::WindowClassAtom)
    {
        UnregisterClassA((LPCSTR)Globals::WindowClassAtom, DllInstance);
        Globals::WindowClassAtom = NULL;
    }
}

/**************************************************************************\
*
* Function Description:
*
*   If the thread quits without cleaning up, this fixes our state
*   to avoid crashing later.
*
*   "Cleans up" what it can - keeps the state consistent, but may leak.
*
* Preconditions:
*
*   BackgroundThreadCriticalSection must be held.
*
* History:
*
*   9/16/2000 agodfrey
*       Created it.
*
\**************************************************************************/

VOID
SimulateInternalNotificationShutdown()
{
    // UnhookWinEvent can't be called from a different thread; so if this
    // causes a leak, we can't help it.
    
    Globals::WinEventHandle = NULL;

    // DestroyWindow can't be called from a different thread; so if this
    // causes a leak, we can't help it.    
    
    Globals::HwndNotify = NULL;
    
    // I don't know about UnregisterClass. I'm assuming we can't call it here.
    // Anyway, the window may not have been destroyed, and MSDN says that must
    // happen first. So, if need be, we'll leak this too.
    
    Globals::WindowClassAtom = NULL;
}

/**************************************************************************\
*
* Function Description:
*
*   Starts our top-level window, and sets up the WndProc and WinEventHook.
*   This must be called from a GUI thread - it's called from either our
*   own background thread, or by the app (via callback pointers returned
*   from GdiplusStartup).
*
* History:
*
*   9/15/2000 agodfrey
*       Created it.
*
\**************************************************************************/

GpStatus WINAPI 
NotificationStartup(
    OUT ULONG_PTR *token
    )
{
    GdiplusStartupCriticalSection critsec;

    // Generate the first token, if necessary.
    // Also handles wraparound.
    
    if (Globals::NotificationInitToken == 0)
    {
        Globals::NotificationInitToken = GenerateInitToken();
        
        // Make sure that the token isn't one of the "special" values.
        
        if (Globals::NotificationInitToken <= NotificationModuleTokenMax)
        {
            Globals::NotificationInitToken = NotificationModuleTokenMax + 1;
        }
    }
    
    // If there's no hidden window yet, create one.
    
    if (Globals::HiddenWindowOwnerToken == NotificationModuleTokenNobody)
    {
        // If there's a background thread, then the owner should be set to
        // 'NotificationModuleTokenGdiplus'.
        
        ASSERT (Globals::ThreadNotify == NULL);

        {
            // We take BackgroundThreadCriticalSection because that's a
            // precondition for InternalNotificationStartup(). I know that we
            // don't actually need to (there's no background thread at this
            // point) - but code can change, so this is safer.

            BackgroundThreadCriticalSection critsec;

            if (!InternalNotificationStartup())
            {
                return GenericError;
            }
        }

        // Store the token of this calling module - when it calls
        // NotificationShutdown, we must destroy the hidden window (and
        // start up the background thread, if necessary).

        Globals::HiddenWindowOwnerToken = Globals::NotificationInitToken;
    }
        
    *token = Globals::NotificationInitToken;

    // Increment the token counter for the next module
    
    Globals::NotificationInitToken++;
    
    return Ok;
}

/**************************************************************************\
*
* Function Description:
*
*   Shuts down our top-level window, WndProc and WinEventHook.
*   This must be called from a GUI thread - it's called from either our
*   own background thread, or by the app (via callback pointers returned
*   from GdiplusStartup).
*
* History:
*
*   9/15/2000 agodfrey
*       Created it.
*
\**************************************************************************/

VOID WINAPI
NotificationShutdown(
    ULONG_PTR token
    )
{
    GdiplusStartupCriticalSection critsec;
    
    // The token they pass us should be the one we gave them, so it shouldn't
    // be one of the 'special values'.
    
    if (token <= NotificationModuleTokenMax)
    {
        RIP(("Invalid token passed to NotificationShutdown"));
        
        // Ignore the call.
        
        return;
    }
    
    if (token == Globals::HiddenWindowOwnerToken)
    {
        // The module that created the hidden window is shutting down.
        
        // There shouldn't be a background thread.
        ASSERT (Globals::ThreadNotify == NULL);
            
        {
            BackgroundThreadCriticalSection critsec;

            InternalNotificationShutdown();
        }

        Globals::HiddenWindowOwnerToken = NotificationModuleTokenNobody;

        // If this is not the final module to shut down, start up the
        // background thread

        if (Globals::LibraryInitRefCount > 1)
        {
            if (!BackgroundThreadStartup())
            {
                // !!! [johnstep] Ack, what can we do now? Another client may
                //                be happily using GDI+ and now we've lost
                //                our message notifications.

                WARNING(("Could not start background thread"));
            }
        }
    }
}    

////////////////////////////// BACKGROUND THREAD ///////////////////////////////

/**************************************************************************\
*
* Function Description:
*
*   Thread proc for our background GUI thread. Sets up a hidden window,
*   WndProc and WinEventHook, then starts the message loop.
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*   9/15/2000 agodfrey
*       #175866: Improved GDI+ startup, shutdown and event notification
*
\**************************************************************************/

DWORD
WINAPI
BackgroundThreadProc(
    VOID*
    )
{
    BOOL error=FALSE;
    HANDLE threadQuitEvent;
    
    {
        BackgroundThreadCriticalSection critsec;

        // Read threadQuitEvent under the critical section - ensures that
        // we don't get the NULL that was there before the main thread
        // initialized it. We can assume, though, that it won't change until
        // this thread ends.
        
        threadQuitEvent = Globals::ThreadQuitEvent;

        if (!InternalNotificationStartup())
        {
            error = TRUE;
        }
    }

    if (error)
    {
        return 0;
    }

    // [agodfrey] We used to have a call to "WaitForInputIdle" here, 
    // which caused problems. It was motivated by Shell and DDE - 
    // since calling GetMessage() signals user that "the app is 
    // ready to receive DDE messages", and we were doing
    // it in PROCESS_ATTACH, long before the app was really ready.
    //
    // Now, we simply disallow initializing GDI+ in PROCESS_ATTACH.
    
    // Process window messages
    // We use MsgWaitForMultipleObjects, so that we can catch both messages
    // and our "quit" event being signalled.
    
    DWORD dwWake;
    
    MSG msg;
    BOOL quit = FALSE;
    
    while (!quit)
    {
        dwWake = MsgWaitForMultipleObjects(
            1,
            &threadQuitEvent,
            FALSE,
            INFINITE,
            QS_ALLINPUT);
            
        if (dwWake == WAIT_OBJECT_0)
        {
            // Our "quit" event was signaled.
            
            quit = TRUE;
            break;
        }
        else if (dwWake == WAIT_OBJECT_0 + 1)
        {
            // We received a message
            while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
            {
                if (msg.message == WM_QUIT)
                {
                    quit = TRUE;
                    break;
                }
                TranslateMessage(&msg);
                DispatchMessageA(&msg);
            }
        }
        else
        {
            RIP(("Unexpected return value from MsgQaitForMultipleObjects"));
        }
    }

    // Clean up:
    
    {
        BackgroundThreadCriticalSection critsec;
        InternalNotificationShutdown();
    }
    
    return 1;
}

/**************************************************************************\
*
* Function Description:
*
*   Starts up the background thread. If the user doesn't ask us to piggyback
*   our hidden window onto their main GUI thread, we end up here, to create
*   our own.
*
* Preconditions:
*
*   GdiplusStartupCriticalSection must be held.
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*   9/15/2000 agodfrey
*       #175866: Improved GDI+ startup, shutdown and event notification
*
\**************************************************************************/

BOOL
BackgroundThreadStartup()
{
    ASSERT(Globals::HiddenWindowOwnerToken == NotificationModuleTokenNobody);
    
    // [agodfrey] Create an event object. We'll use this to tell the 
    // background thread to quit.

    HANDLE threadQuitEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
    if (threadQuitEvent == NULL)
    {
        WARNING(("CreateEvent failed: %d", GetLastError()));
        BackgroundThreadShutdown();
        return FALSE;
    }
    
    {
        // Store threadQuitEvent while holding the correct critsec.

        BackgroundThreadCriticalSection critsec;
    
        Globals::ThreadQuitEvent = threadQuitEvent;
    }

    // Create the background thread.

    Globals::ThreadNotify = CreateThread(NULL,                        // LPSECURITY_ATTRIBUTES
                                         0,                           // same stack size
                                         &BackgroundThreadProc,
                                         0,                           // parameter to thread
                                         0,                           // creation flags
                                         &Globals::ThreadId);


    if (Globals::ThreadNotify == NULL)
    {
       BackgroundThreadShutdown();
       return FALSE;
    }
    
    // Record the fact that GDI+ has its own hidden window, and so
    // NotificationStartup shouldn't create another one.
    
    Globals::HiddenWindowOwnerToken = NotificationModuleTokenGdiplus;
    
    return TRUE;
}

/**************************************************************************\
*
* Function Description:
*
*   Shuts down the background thread.
*
* Preconditions:
*
*   GdiplusStartupCriticalSection must be held.
*   BackgroundThreadCriticalSection must *NOT* be held (we would deadlock).
*
* History:
*
*   7/23/1999 ericvan
*       Created it.
*   9/15/2000 agodfrey
*       #175866: Improved GDI+ startup, shutdown and event notification.
*       Made it more robust by adding an event, and changing the thread's
*       message loop so that it quits when the event is signaled.
*
\**************************************************************************/

VOID
BackgroundThreadShutdown()
{
    // Stop the background thread
    
    if (Globals::ThreadNotify != NULL)
    {
        ASSERT(Globals::HiddenWindowOwnerToken == NotificationModuleTokenGdiplus);
    
        // We want to be careful not to hold BackgroundThreadCriticalSection
        // while we wait for the thread to terminate, since that could
        // cause a deadlock situation (our wait would time out).
        
        HANDLE threadQuitEvent;
        
        {
            BackgroundThreadCriticalSection critsec;
    
            threadQuitEvent = Globals::ThreadQuitEvent;
        }
    
        ASSERT(threadQuitEvent); // If it's NULL, ThreadNotify should be NULL.
        
        SetEvent(threadQuitEvent);

        DWORD ret = WaitForSingleObject(Globals::ThreadNotify, INFINITE);
        ASSERT(ret == WAIT_OBJECT_0);
        
        CloseHandle(Globals::ThreadNotify);
        Globals::ThreadNotify = NULL;
        Globals::ThreadId = 0;
    
        Globals::HiddenWindowOwnerToken = NotificationModuleTokenNobody;
    }

    {
        BackgroundThreadCriticalSection critsec;
            
        // [agodfrey] I discovered that, if InternalGdiplusShutdown is called 
        // from PROCESS_DETACH, the system will have terminated the thread 
        // already; WaitForSingleObject returns immediately because the 
        // thread has already stopped running. 
        //
        // In this case, InternalNotificationShutdown() isn't called, i.e. the
        // globals it cleans up are still non-NULL. I deem this "ok" because,
        // if we're in PROCESS_DETACH, no-one's going to read those variables
        // again.
        //
        // Still, I don't know if there are other legitimate ways for the 
        // thread to end without it cleaning up properly. So we call 
        // SimulateInternalNotificationShutdown() just to be safe - it's not
        // very expensive.
        
        SimulateInternalNotificationShutdown();
        
        // Destroy the "quit" event
        
        if (Globals::ThreadQuitEvent)
        {
            CloseHandle(Globals::ThreadQuitEvent);
            Globals::ThreadQuitEvent = NULL;
        }
    }
}