/******************************Module*Header*******************************\
* Module Name: sswproc.cxx
*
* Window procedure functions.
*
* Copyright (c) 1996 Microsoft Corporation
\**************************************************************************/

#include "mtk.hxx"
#include "mtkinit.hxx"
#include "palette.hxx"
#include "clear.hxx"
#include "mtkwproc.hxx"

//mf: some of this stuff should be per window-group eventually
SSW_TABLE sswTable;

//mf: this needs to be per window group
static BOOL bInBackground;

// forward declarations of internal functions

LONG SS_ScreenSaverProc( HWND, UINT, WPARAM, LPARAM );
LONG MainPaletteManageProc(HWND, UINT, WPARAM, LPARAM );
static LONG InputManageProc(HWND, UINT, WPARAM, LPARAM );

static void ForceRedraw( HWND Window );

static void ssw_RealizePalette( PMTKWIN pssw, BOOL bBackground );
static void ssw_DeletePalette( PMTKWIN pssw );


/**************************************************************************\
* ScreenSaverProc
*
* Processes messages for the top level screen saver window.
*
* Unhandled msgs are sent to DefScreenSaverProc
\**************************************************************************/

LONG 
mtkWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    MTKWIN *pmtkwin;

    switch (message)
    {
        case WM_CREATE:
        case WM_ERASEBKGND:
            return SS_ScreenSaverProc( hwnd, message, wParam, lParam);

        case WM_ACTIVATE:
            if ( LOWORD(wParam) == WA_INACTIVE ) {
                SS_DBGMSG( "Main_Proc: WM_ACTIVATE inactive\n" );
                bInBackground = TRUE;
            } else {
                SS_DBGMSG( "Main_Proc: WM_ACTIVATE active\n" );
                bInBackground = FALSE;
            }

            // fall thru

        case WM_QUERYNEWPALETTE:
        case WM_PALETTECHANGED:
        case WM_SYSCOLORCHANGE:
        case MTK_WM_PALETTE:
            return( MainPaletteManageProc( hwnd, message, wParam, lParam ) );


        case WM_DESTROY:
            pmtkwin = sswTable.PsswFromHwnd( hwnd );

            if( ! pmtkwin ) {
                SS_WARNING( "WM_DESTROY : pmtkwin is NULL\n" );
                return 0;
            }

//mf: Before deleting this top level window, we need to use its
// still-valid dc to things like restore SystemPaletteUse mode.  Ideally this
// should be done after ~SSW has dumped GL, but ~SSW also releases the DC.
// If this is a problem, we can create a new function SSW::DeleteGL that just
// gets rid of the GL part

            if( sswTable.GetNumWindows() == 1 ) {
                // This is the last window, special considerations

                // Handle any palette stuff
                if( gpssPal )
                    ssw_DeletePalette( pmtkwin );

                delete pmtkwin;

                // All win's have now been deleted - remove global ptr to top of
                // window chain.
                gpMtkwinMain = NULL;
            }

// mf: ! this kills the app !, that's not what we want...
// Doesn't seem to make much of a difference if call it or not
//            PostQuitMessage(0);
            return 0;

        case WM_PAINT:
            SS_DBGMSG( "mtkWndProc: WM_PAINT\n" );

            pmtkwin = sswTable.PsswFromHwnd( hwnd );
            pmtkwin->Repaint( TRUE );

#ifdef SS_DO_PAINT
            // We do the painting rather than letting the system do it
            hdc = BeginPaint(hwnd, &ps);

            // This is case where bg brush is NULL and we have to do repaint
            // We only do it after bInited, as this will avoid the first
            // -> bInited removed 5/1/97
            // WM_PAINT for the entire window.
            DrawGdiRect( hdc, ghbrBg, &ps.rcPaint );
            EndPaint(hwnd, &ps);

            return 0; // painting has been handled by us
#endif // SS_DO_PAINT

            break;

        case MTK_WM_REDRAW:
            SS_DBGMSG( "mtkWndProc: MTK_WM_REDRAW\n" );
            pmtkwin = sswTable.PsswFromHwnd( hwnd );
            pmtkwin->Display();
            return 0;

        case WM_MOVE:
            SS_DBGMSG( "mtkWndProc: WM_MOVE\n" );
            pmtkwin = sswTable.PsswFromHwnd( hwnd );
            pmtkwin->pos.x = LOWORD(lParam);
            pmtkwin->pos.y = HIWORD(lParam);
            break;
//mf
#if 1
// This allows us to pick up under-bits on window moves
        case WM_WINDOWPOSCHANGING:
            {
                LPWINDOWPOS lpwp = (LPWINDOWPOS) lParam;
                SS_DBGMSG1( "mtkWndProc: WM_WINDOWPOSCHANGING, flags = %x\n",
                            lpwp->flags );
                pmtkwin = sswTable.PsswFromHwnd( hwnd );
                if( pmtkwin->pBackgroundBitmap ) {
#if 0
                    // If window moving, don't want to copy old bits...
        //mf: this actually fukin works (sometimes) !
                    if( !(lpwp->flags & SWP_NOMOVE) ) {
                SS_DBGMSG( "mtkWndProc: WM_WINDOWPOSCHANGING, moving\n" );
                        // window moving
                        if( !(lpwp->flags & SWP_NOCOPYBITS) ) {
                            lpwp->flags |= SWP_NOCOPYBITS;
                        }
                    }
                }
#else
// Things seem to work better if we always force this flag, otherwise now
// and then get partial update rects, even if window active and moving (in
// which case update rect should always be entire client area.
                            lpwp->flags |= SWP_NOCOPYBITS;
                }
#endif
            }
            break;
        case WM_WINDOWPOSCHANGED:
            {
                LPWINDOWPOS lpwp = (LPWINDOWPOS) lParam;
                SS_DBGMSG1( "mtkWndProc: WM_WINDOWPOSCHANGED, flags = %x\n",
                            lpwp->flags );
                pmtkwin = sswTable.PsswFromHwnd( hwnd );
                if( pmtkwin->pBackgroundBitmap ) {
                    if( !(lpwp->flags & SWP_NOMOVE) ) {
                        // window moved
//                SS_DBGMSG( "mtkWndProc: WM_WINDOWPOSCHANGED, moved\n" );
                    }
                }
            }
            break;
#endif

        case WM_TIMER:

            SS_DBGMSG( "mtkWndProc: WM_TIMER\n" );

            if( pmtkwin = sswTable.PsswFromHwnd( hwnd ) )
                pmtkwin->mtkAnimate();

            return 0;
    }

//mf: for now...
    return SS_ScreenSaverProc(hwnd, message, wParam, lParam);
}

/**************************************************************************\
* SS_ScreenSaverProc
*
* Wndproc for child windows, and some messages from top-level window
*
* Unhandled msgs are sent to DefWindowProc
\**************************************************************************/

LONG 
SS_ScreenSaverProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    int i;
    int retVal;
    MTKWIN *pmtkwin;

    switch (message)
    {
        case WM_CREATE:
            SS_DBGMSG1( "SS_Proc: WM_CREATE for 0x%x\n", hwnd );

            pmtkwin = (PMTKWIN) ( ((LPCREATESTRUCT)lParam)->lpCreateParams ); 
            sswTable.Register( hwnd, pmtkwin );
            pmtkwin->hwnd = hwnd;
            break;

        case MTK_WM_PALETTE:
            return( MainPaletteManageProc( hwnd, message, wParam, lParam ) );

        case WM_DESTROY:
            pmtkwin = sswTable.PsswFromHwnd( hwnd );

            SS_DBGMSG1( "SS_Proc: WM_DESTROY for 0x%x\n", hwnd );

            // Delete the pssw - this does all necessary cleanup

            if( pmtkwin )
                delete pmtkwin;
            else
                SS_WARNING( "WM_DESTROY : pmtkwin is NULL\n" );

            break;

        case WM_PAINT:
            // We get this msg every time window moves, since SWP_NOCOPYBITS is
            // specified with the window move.
            hdc = BeginPaint(hwnd, &ps);
//mf: will need to call DisplayFunc here...
// -> currently being handled in tkWndProc
            EndPaint(hwnd, &ps);
            break;

        case WM_SIZE:
            SS_DBGMSG( "mtkWndProc: WM_SIZE\n" );
            pmtkwin = sswTable.PsswFromHwnd( hwnd );
            // Suspend drawing if minimized
            if( wParam == SIZE_MINIMIZED ) {
                // Stop any animation
                pmtkwin->animator.Stop(); // noop if no timer
                // We can return here, since for now we don't do anything
                // in a minimized window
                return 0;
            }
            else { // either SIZE_RESTORED or SIZE_MAXIMIZED
                // If there is an animation func, restart animation
//mf: potential problem here if timer was not started...
                pmtkwin->animator.Start();
            }

            pmtkwin->Resize( LOWORD(lParam), HIWORD(lParam) );
            break;

        // these msg's are never received by the child window ?
        case WM_ACTIVATE:
        case WM_QUERYNEWPALETTE:
        case WM_PALETTECHANGED:
            return( MainPaletteManageProc( hwnd, message, wParam, lParam ) );


        case WM_MOUSEMOVE:
        case WM_LBUTTONDOWN:
        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_MBUTTONUP:
        case WM_RBUTTONUP:
        case WM_KEYDOWN:
        case WM_CHAR:
//mf: this can be fn ptr eventually, so ss's can use it too
            return( InputManageProc( hwnd, message, wParam, lParam ) );

        default: 
            return DefWindowProc(hwnd, message, wParam, lParam);
    }
    return 0;
}

/**************************************************************************\
* InputManageProc
*
\**************************************************************************/

static LONG 
InputManageProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    MTKWIN *pmtkwin = sswTable.PsswFromHwnd( hWnd );
    int key;

  switch( message ) {

    case WM_MOUSEMOVE:

        if (pmtkwin->MouseMoveFunc)
        {
            GLenum mask;

            mask = 0;
            if (wParam & MK_LBUTTON) {
                mask |= TK_LEFTBUTTON;
            }
            if (wParam & MK_MBUTTON) {
                mask |= TK_MIDDLEBUTTON;
            }
            if (wParam & MK_RBUTTON) {
                mask |= TK_RIGHTBUTTON;
            }

            if ((*pmtkwin->MouseMoveFunc)( LOWORD(lParam), HIWORD(lParam), mask ))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_LBUTTONDOWN:

        SetCapture(hWnd);

        if (pmtkwin->MouseDownFunc)
        {
            if ( (*pmtkwin->MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
                 TK_LEFTBUTTON) )
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_LBUTTONUP:

        ReleaseCapture();

        if (pmtkwin->MouseUpFunc)
        {
            if ((*pmtkwin->MouseUpFunc)(LOWORD(lParam), HIWORD(lParam), TK_LEFTBUTTON))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_MBUTTONDOWN:

        SetCapture(hWnd);

        if (pmtkwin->MouseDownFunc)
        {
            if ((*pmtkwin->MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
                    TK_MIDDLEBUTTON))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_MBUTTONUP:

        ReleaseCapture();

        if (pmtkwin->MouseUpFunc)
        {
            if ((*pmtkwin->MouseUpFunc)(LOWORD(lParam), HIWORD(lParam),
                TK_MIDDLEBUTTON))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_RBUTTONDOWN:

        SetCapture(hWnd);

        if (pmtkwin->MouseDownFunc)
        {
            if ((*pmtkwin->MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
                TK_RIGHTBUTTON))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_RBUTTONUP:

        ReleaseCapture();

        if (pmtkwin->MouseUpFunc)
        {
            if ((*pmtkwin->MouseUpFunc)(LOWORD(lParam), HIWORD(lParam),
                TK_RIGHTBUTTON))
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_KEYDOWN:
        switch (wParam) {
        case VK_SPACE:          key = TK_SPACE;         break;
        case VK_RETURN:         key = TK_RETURN;        break;
        case VK_ESCAPE:         key = TK_ESCAPE;        break;
        case VK_LEFT:           key = TK_LEFT;          break;
        case VK_UP:             key = TK_UP;            break;
        case VK_RIGHT:          key = TK_RIGHT;         break;
        case VK_DOWN:           key = TK_DOWN;          break;
        default:                key = GL_FALSE;         break;
        }

        if (key && pmtkwin->KeyDownFunc)
        {
            GLenum mask;

            mask = 0;
            if (GetKeyState(VK_CONTROL)) {
                mask |= TK_CONTROL;
            }

            if (GetKeyState(VK_SHIFT)) {

                mask |= TK_SHIFT;
            }

            if ( (*pmtkwin->KeyDownFunc)(key, mask) )
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);

    case WM_CHAR:
        if (('0' <= wParam && wParam <= '9') ||
            ('a' <= wParam && wParam <= 'z') ||
            ('A' <= wParam && wParam <= 'Z')) {

            key = wParam;
        } else {
            key = GL_FALSE;
        }

        if (key && pmtkwin->KeyDownFunc) {
            GLenum mask;

            mask = 0;

            if (GetKeyState(VK_CONTROL)) {
                mask |= TK_CONTROL;
            }

            if (GetKeyState(VK_SHIFT)) {
                mask |= TK_SHIFT;
            }

            if ( (*pmtkwin->KeyDownFunc)(key, mask) )
            {
                ForceRedraw( hWnd );
            }
        }
        return (0);
    }    
    return 0;
}

static void
ForceRedraw( HWND hwnd )
{
    MSG Message;

#if 0
    if (!PeekMessage(&Message, hwnd, WM_PAINT, WM_PAINT, PM_NOREMOVE) )
    {
        InvalidateRect( hwnd, NULL, FALSE );
    }
#else
//mf: There is a problem with doing the redraw via WM_PAINT.  WM_PAINT is sent
// by the system when part of the window needs to be redrawn.  For transparent
// windows, we hook a grab background off of this, so if we use WM_PAINT for
// our redraws, we'll just grab the previous gl image.  Solutions are :
// 1) Call redraw proc immediately here (possible timing problem)
// 2) * Send redraw msg to queue
// Possible side-effect : by not sending a WM_PAINT, the system is less
// informed about what we're doing, but heck, we don't use PAINT for animations
// anyways.
    if (!PeekMessage(&Message, hwnd, MTK_WM_REDRAW, MTK_WM_REDRAW, PM_NOREMOVE) )
    {
        PostMessage( hwnd, MTK_WM_REDRAW, 0, 0l );
    }
#endif
}

/**************************************************************************\
* UpdateDIBColorTable
*
* Wrapper for SSDIB_UpdateColorTable.  
*
* This controls the hPal parameter for SSDIB_UpdateColorTable.
*
\**************************************************************************/

void
ssw_UpdateDIBColorTable( HDC hdcbm, HDC hdcwin )
{
    SS_PAL *pssPal = gpssPal;

    if( !pssPal )
        return;
#if 0
    HPALETTE hpal = pssPal->bTakeOver ? pssPal->hPal : NULL;
#else
    HPALETTE hpal =  pssPal->hPal;
#endif

    SSDIB_UpdateColorTable( hdcbm, hdcwin, hpal );
}


/**************************************************************************\
* RealizePalette
*
\**************************************************************************/

static void
ssw_RealizePalette( PMTKWIN pmtkwin, BOOL bBackground )
{
    // assumed pssPal valid if get here
    SS_PAL *pssPal = gpssPal;

    if( !pmtkwin->hrc ) {
        // Can assume this window doesn't need to worry about palettes, but
        // if any of its children are subWindows, it will have to take care
        // of it *for* them.
            return; // no hrc and no subWindow children
    }
    pssPal->Realize( pmtkwin->hwnd, pmtkwin->hdc, bBackground );
}

/**************************************************************************\
* ssw_DeletePalette
*
\**************************************************************************/

static void
ssw_DeletePalette( PMTKWIN pmtkwin )
{
    SS_PAL *pssPal = gpssPal;

//mf: !!! ? this din't seem to be used
#if 0
    if( pssPal->bTakeOver ) {
        // We took over the system palette - make a note of this
        // for any special ss termination conditions.
        gpss->flags |= SS_PALETTE_TAKEOVER;
    }
#endif
    pssPal->SetDC( pmtkwin->hdc );
    delete pssPal;
    gpssPal = NULL;
}

/**************************************************************************\
* PaletteManage Procs
\**************************************************************************/

/* palette related msgs's:
    - WM_ACTIVATE:
        The WM_ACTIVATE message is sent when a window is being activated or 
        deactivated. This message is sent first to the window procedure of 
        the top-level window being deactivated; it is then sent to the 
        window procedure of the top-level window being activated. 

    - WM_QUERYNEWPALETTE:
        The WM_QUERYNEWPALETTE message informs a window that it is about 
        to receive the keyboard focus, giving the window the opportunity 
        to realize its logical palette when it receives the focus. 

        If the window realizes its logical palette, it must return TRUE; 
        otherwise, it must return FALSE. 

    - WM_PALETTECHANGED:
        The WM_PALETTECHANGED message is sent to all top-level and overlapped 
        windows after the window with the keyboard focus has realized its 
        logical palette, thereby changing the system palette. This message 
        enables a window that uses a color palette but does not have the 
        keyboard focus to realize its logical palette and update its client 
        area. 

        This message must be sent to all top-level and overlapped windows, 
        including the one that changed the system palette. If any child 
        windows use a color palette, this message must be passed on to them 
        as well. 
        To avoid creating an infinite loop, a window that receives this 
        message must not realize its palette, unless it determines that 
        wParam does not contain its own window handle. 

    - WM_SYSCOLORCHANGE:
        The WM_SYSCOLORCHANGE message is sent to all top-level windows when 
        a change is made to a system color setting. 

    - MTK_WM_PALETTE:
        Internal msg.  Uses:
        - In fullscreen mode, we send this from Main wndproc to main 
          window's children on WM_ACTIVATE.
        - When this is received in SS_ScreenSaverProc, if fullscreen,
          it does:
                    UnrealizeObject( pssPal->hPal );
                    RealizePalette( hdc );
          otherwise, it is passed to PaletteManageProc, where
          Realize is called (for 'floater' windows to realize 
          their palettes).
        - It is also sent by DelayPaletteRealization() when it can't get
          the system palette.

*/


/**************************************************************************\
* MainPaletteManageProc
*
* Top-level palette management proc.

* Returns immediately if no palette set - otherwise calls through
* paletteManageProc function pointer
*
\**************************************************************************/

LONG 
MainPaletteManageProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    if( !gpssPal )
        // No palette management required
        return 0;

    // else call approppriate palette manage proc
    return (*gpssPal->paletteManageProc)(hwnd, message, wParam, lParam);
}

/**************************************************************************\
* FullScreenPaletteManageProc
*
* Processes messages relating to palette management in full screen mode.
*
\**************************************************************************/

LONG 
FullScreenPaletteManageProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    SS_PAL *pssPal;
    MTKWIN *pmtkwin;

    switch (message)
    {
        case WM_ACTIVATE:

#if SS_DEBUG
            if ( LOWORD(wParam) == WA_INACTIVE )
                SS_DBGMSG1( "FullScreen_PMProc: WM_ACTIVATE : inactive for 0x%x\n",
                           hwnd );
            else
                SS_DBGMSG1( "FullScreen_PMProc: WM_ACTIVATE : active for 0x%x\n",
                           hwnd );
#endif

            // !! This msg is only sent to main top level window
            pmtkwin = sswTable.PsswFromHwnd( hwnd );

            pssPal = gpssPal;
            if ( pssPal->bUseStatic ) {
                HDC hdc = pmtkwin->hdc; // hdc *always* valid for top-level pssw
                // Note: wParam = 0 when window going *inactive*
                SetSystemPaletteUse( hdc, wParam ? SYSPAL_NOSTATIC
                                                : pssPal->uiOldStaticUse);
            }

            // Send MTK_WM_PALETTE msg to main window
            SendMessage( hwnd, MTK_WM_PALETTE, wParam, 0);
            break;

        case MTK_WM_PALETTE:

            SS_DBGMSG1( "FullScreen_PMProc: MTK_WM_PALETTE for 0x%x\n", hwnd );

            pmtkwin = sswTable.PsswFromHwnd( hwnd );

            HDC hdc;
            if( hdc = pmtkwin->hdc )
            {
                pssPal = gpssPal;

//mf: this should call thru ssw_RealizePalette for bitmap case ? (for now
// don't need to, since we take over palette...)
                // This resets the logical palette, causing remapping of
                // logical palette to system palette
           // mf: !!! ?? how come no dc with UnrealizeObject ?  does that
                // mean its done once per app, not per child window ?
            // yeah, we should move this up...
                UnrealizeObject( pssPal->hPal );
                RealizePalette( hdc );
            }
            break;
    }
    return 0;
}

/**************************************************************************\
* PaletteManageProc
*
* Processes messages relating to palette management for the general case.
*
* Note: this msg handling strategy is based loosely on the tk, so any changes 
* there should be reflected here
\**************************************************************************/

LONG 
PaletteManageProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // One global palette for all windows
    MTKWIN *pmtkwin;

    if( !gpssPal )
        return 0;

    switch (message)
    {
      case WM_ACTIVATE:

        SendMessage( hwnd, MTK_WM_PALETTE, bInBackground, 0);

        // Allow DefWindowProc() to finish the default processing (which 
        // includes changing the keyboard focus).
//mf: I added this - watch out for ss implications
        return DefWindowProc( hwnd, message, wParam, lParam );

        break;

      case WM_QUERYNEWPALETTE:

#if 0
        SS_DBGMSG1( "Palette_Proc: WM_QUERYNEWPALETTE for 0x%x\n", hwnd );
        // We don't actually realize palette here (we do it at WM_ACTIVATE
        // time), but we need the system to think that we have so that a
        // WM_PALETTECHANGED message is generated.
//mf: why can't we just realize here ? and who wants even more messages to
// be generated !!! :)

        // This is the only msg preview mode gets wrt palettes !
        if( !ss_fPreviewMode() )
            return (1);

        // We are in preview mode - realize the palette
        SendMessage( hwnd, MTK_WM_PALETTE, bInBackground, 0);
        break;
#else
            return (1);
#endif

      case WM_PALETTECHANGED:

        SS_DBGMSG1( "Palette_Proc: WM_PALETTECHANGED for 0x%x\n", hwnd );
        // Respond to this message only if the window that changed the palette
        // is not this app's window.

        // We are not the foreground window, so realize palette in the
        // background.  We cannot call Realize to do this because
        // we should not do any of the gbUseStaticColors processing while
        // in background.

        // Actually, we *can* be the fg window, so don't realize if
        // we're in foreground

        if( (hwnd != (HWND) wParam) && bInBackground )
            SendMessage( hwnd, MTK_WM_PALETTE, TRUE, 0);

        break;

      case WM_SYSCOLORCHANGE:

        // If the system colors have changed and we have a palette
        // for an RGB surface then we need to recompute the static
        // color mapping because they might have been changed in
        // the process of changing the system colors.

          SS_DBGMSG1( "Palette_Proc: WM_SYSCOLORCHANGE for 0x%x\n", hwnd );
          gpssPal->ReCreateRGBPalette();
          SendMessage( hwnd, MTK_WM_PALETTE, bInBackground, 0);
          break;
            
      case MTK_WM_PALETTE:

          SS_DBGMSG2( "Palette_Proc: MTK_WM_PALETTE for 0x%x, bg = %d\n", 
                          hwnd, wParam );


          // Realize palette for this window and its children
          // wParam = TRUE if realize as bg

          pmtkwin = sswTable.PsswFromHwnd( hwnd );
          ssw_RealizePalette( pmtkwin, wParam );
          break;
    }
    return 0;
}

/******************************Public*Routine******************************\
* SSW_TABLE constructor
*
\**************************************************************************/

SSW_TABLE::SSW_TABLE()
{
    nEntries = 0;
}

/******************************Public*Routine******************************\
* Register
*
* Register a HWND/PSSW pair.
\**************************************************************************/

void
SSW_TABLE::Register( HWND hwnd, PMTKWIN pssw )
{
    SSW_TABLE_ENTRY *pEntry;

    // Check if already in table
    if( PsswFromHwnd( hwnd ) )
        return;

    // put hwnd/pssw pair in the table
    pEntry = &sswTable[nEntries];
    pEntry->hwnd = hwnd;
    pEntry->pssw = pssw;
    nEntries++;
}

/******************************Public*Routine******************************\
* PsswFromHwnd
*
* Return PSSW for the HWND
\**************************************************************************/

PMTKWIN
SSW_TABLE::PsswFromHwnd( HWND hwnd )
{
    int count = nEntries;
    SSW_TABLE_ENTRY *pEntry = sswTable;

    while( count-- ) {
        if( pEntry->hwnd == hwnd )
            return pEntry->pssw;
        pEntry++;
    }
    return NULL;
}

/******************************Public*Routine******************************\
* Remove
*
* Remove HWND/PSSW entry from table
\**************************************************************************/

BOOL
SSW_TABLE::Remove( HWND hwnd )
{
    SSW_TABLE_ENTRY *pEntry = sswTable;

    // Locate the hwnd/pssw pair

    for( int count = 0 ; count < nEntries ; count++, pEntry++ ) {
        if( pEntry->hwnd == hwnd )
            break;
    }

    if( count == nEntries )
        // couldn't find it in the table
        return FALSE;

    // Remove entry / shuffle up other entries
    for( int i = count; i < nEntries-1; i ++ ) {
        sswTable[i] = sswTable[i+1];
    }

    nEntries--;
    return TRUE;
}