wwmouse.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Command & Conquer                                            *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Library/wwmouse.cpp                          $*
 *                                                                                             *
 *                      $Author:: Byon_g                                                      $*
 *                                                                                             *
 *                     $Modtime:: 8/11/97 10:14a                                              $*
 *                                                                                             *
 *                    $Revision:: 2                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   Callback_Process_Mouse -- Mouse O/S callback function.                                    *
 *   WWMouseClass::WWMouseClass -- Constructor for mouse handler object.                       *
 *   WWMouseClass::~WWMouseClass -- Destructor for mouse handler object.                       *
 *   WWMouseClass::Get_Mouse_State -- Fetch the current mouse visibility state.                *
 *   WWMouseClass::Set_Cursor -- Set the mouse cursor shape.                                   *
 *   WWMouseClass::Is_Data_Valid -- Determines if there is valid shape image data.             *
 *   WWMouseClass::Validate_Copy_Buffer -- Checks for and validates the background copy buffer.*
 *   WWMouseClass::Matching_Rect -- Finds rectangle of current cursor position & size.         *
 *   WWMouseClass::Save_Background -- Saves the background to a copy buffer.                   *
 *   WWMouseClass::Restore_Background -- Restores the image back where it came from.           *
 *   WWMouseClass::Draw_Mouse -- Manually draw the mouse to the surface specified.             *
 *   WWMouseClass::Erase_Mouse -- Restores the surface after a Draw_Mouse call.                *
 *   WWMouseClass::Raw_Draw_Mouse -- Draws the mouse to the surface specified.                 *
 *   WWMouseClass::Low_Show_Mouse -- Shows the mouse and saves the background.                 *
 *   WWMouseClass::Low_Hide_Mouse -- Restores the surface image in order to hide the mouse.    *
 *   WWMouseClass::Show_Mouse -- Shows the mouse on the visible surface.                       *
 *   WWMouseClass::Hide_Mouse -- Hides the mouse from the visible surface.                     *
 *   WWMouseClass::Capture_Mouse -- Capture the mouse into the mouse handler region.           *
 *   WWMouseClass::Release_Mouse -- Release the mouse back to the O/S.                         *
 *   WWMouseClass::Conditional_Hide_Mouse -- Hides the mouse if it would overlap the region spe*
 *   WWMouseClass::Conditional_Show_Mouse -- Releases the mouse hiding region tracking.        *
 *   WWMouseClass::Convert_Coordinate -- Convert an O/S coordinate into a logical coordinate.  *
 *   WWMouseClass::Get_Bounded_Position -- Fetches the mouse position from the O/S.            *
 *   WWMouseClass::Update_Mouse_Position -- Updates the mouse position to match that specified.*
 *   WWMouseClass::Process_Mouse -- Mouse processing callback routine.                         *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#include    "always.h"
#include    "_convert.h"
#include    "_mono.h"
#include    "blit.h"
#include    "bsurface.h"
#include    "draw.h"
#include    "shapeset.h"
#include    "surface.h"
#include    "win.h"
#include    "wwmouse.h"
#include    <assert.h>
 
 
/*
**  Persistant mouse object pointer that is used to facilitate access to the mouse
**  handler object outside of the context of a member function. This will be set to the
**  mouse object most recently created.
*/
static WWMouseClass * _MousePtr = NULL;
 
 
/***********************************************************************************************
 * Callback_Process_Mouse -- Mouse O/S callback function.                                      *
 *                                                                                             *
 *    This routine is called periodically by the operating system. It handles updating the     *
 *    mouse cursor position to match the mouse movement.                                       *
 *                                                                                             *
 * INPUT:   n/a                                                                                *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void CALLBACK Callback_Process_Mouse( UINT, UINT, DWORD, DWORD, DWORD  )
{
    if (_MousePtr != NULL) {
        _MousePtr->Process_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::WWMouseClass -- Constructor for mouse handler object.                         *
 *                                                                                             *
 *    This is the constructor for the mouse handler object. It is assigned to a surface and    *
 *    given a confining rectangle. The mouse begins in a non-captured state.                   *
 *                                                                                             *
 * INPUT:   surfaceptr  -- Pointer to the visible display surface that will show the mouse.    *
 *                                                                                             *
 *          confine     -- The confining rectangle within the visible surface. The mouse       *
 *                         coordinates are bound to this rectangle.                            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
WWMouseClass::WWMouseClass(Surface * surfaceptr, HWND window) :
    Blocked(false),
    MouseState(-1),
    IsCaptured(false),
    MouseX(0),
    MouseY(0),
    SurfacePtr(surfaceptr),
    Window(window),
    MouseShape(NULL),
    ShapeNumber(0),
    MouseXHot(0),
    MouseYHot(0),
    Background(NULL),
    Alternate(NULL),
    SidebarAlternate(NULL),
    ConditionalRect(0,0,0,0),
    ConditionalState(-1),
    TimerHandle(0)
{
    _MousePtr = this;
    TimerHandle = timeSetEvent(1000/60, 1, Callback_Process_Mouse, 0, TIME_PERIODIC);
    Calc_Confining_Rect();
    MouseXHot = ConfiningRect.X + (ConfiningRect.Width/2);
    MouseYHot = ConfiningRect.Y + (ConfiningRect.Height/2);
}
 
 
/***********************************************************************************************
 * WWMouseClass::~WWMouseClass -- Destructor for mouse handler object.                         *
 *                                                                                             *
 *    This will remove the mouse handler object from being processed. It returns the mouse     *
 *    back to O/S control.                                                                     *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
WWMouseClass::~WWMouseClass(void)
{
    if (TimerHandle != 0) {
        timeKillEvent(TimerHandle);
        _MousePtr = NULL;
    }
 
    delete Background;
    Background = NULL;
 
    delete Alternate;
    Alternate = NULL;
    delete SidebarAlternate;
    SidebarAlternate = NULL;
}
 
 
void WWMouseClass::Calc_Confining_Rect(void)
{
    RECT rect;
    GetClientRect(Window, &rect);
 
    POINT point;
    point.x = rect.left;
    point.y = rect.top;
    ClientToScreen(Window, &point);
 
    POINT lr;
    lr.x = rect.right;
    lr.y = rect.bottom;
    ClientToScreen(Window, &lr);
 
    ConfiningRect = Rect(point.x, point.y, lr.x-point.x, lr.y-point.y);
//  ConfiningRect = Rect(point.x, point.y, lr.x-point.x+1, lr.y-point.y+1);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Get_Mouse_State -- Fetch the current mouse visibility state.                  *
 *                                                                                             *
 *    This routine is used to retrieve the current mouse state as it relates to visiblity.     *
 *    By using this routine it is possible to determine if the mouse is visible.               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current mouse visibility state. If the return value is less than  *
 *          0 (i.e., negative), then the mouse is hidden.                                      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
int WWMouseClass::Get_Mouse_State(void) const
{
    if (!Is_Captured()) {
        ShowCursor(FALSE);
        int state = ShowCursor(TRUE);
        return(state);
    }
    return(MouseState);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Set_Cursor -- Set the mouse cursor shape.                                     *
 *                                                                                             *
 *    This routine sets the mouse cursor image and hot-spot. The shape only applies to the     *
 *    mouse when it is captured (the normal case). Repeated calls to this routine is used      *
 *    to give the mouse animation.                                                             *
 *                                                                                             *
 * INPUT:   xhotspot, yhotspot   -- The X,Y offset from the upper left corner of the shape     *
 *                                  that specifies the hot-spot of the image. Positive values  *
 *                                  are right and down from the upper left corner.             *
 *                                                                                             *
 *          cursor   -- Pointer to the shape data.                                             *
 *                                                                                             *
 *          shape    -- The shape number to use within the shape data set specified.           *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Set_Cursor(int xhotspot, int yhotspot, ShapeSet const * cursor, int shape)
{
    if (cursor != NULL) {
        if (Is_Captured()) {
            Block_Mouse();
            if (!Is_Hidden()) Low_Hide_Mouse();
            MouseShape = cursor;
            ShapeNumber = shape;
            MouseXHot = xhotspot;
            MouseYHot = yhotspot;
            if (!Is_Hidden()) Low_Show_Mouse();
            Unblock_Mouse();
        } else {
            MouseShape = cursor;
            ShapeNumber = shape;
            MouseXHot = xhotspot;
            MouseYHot = yhotspot;
        }
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Is_Data_Valid -- Determines if there is valid shape image data.               *
 *                                                                                             *
 *    This routine does a simple check to determine if the shape handler has been supplied     *
 *    a pointer to shape imagery. Any internal routine that requires the data to be present    *
 *    should call this routine to be sure it actually is.                                      *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Has a shape image data pointer been supplied to this mouse handler?          *
 *                                                                                             *
 * WARNINGS:   When the mouse object is first created, no image data has been assigned. The    *
 *             Set_Cursor must be called before this routine will return TRUE.                 *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
bool WWMouseClass::Is_Data_Valid(void) const
{
    if (MouseShape != NULL) {
        return(true);
    }
    return(false);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Validate_Copy_Buffer -- Checks for and validates the background copy buffer.  *
 *                                                                                             *
 *    This routine checks and allocates if necessary a buffer that is big enough to hold the   *
 *    background image under the mouse. Whenever the background buffer is needed, this routine *
 *    should be called to ensure that it is valid.                                             *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Is the buffer valid?                                                         *
 *                                                                                             *
 * WARNINGS:   This routine might fail if there was insufficient memory.                       *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
bool WWMouseClass::Validate_Copy_Buffer(void)
{
    if (Is_Data_Valid()) {
 
        /*
        **  If there is a background buffer already allocated, then verify that
        **  it is large enough for the current shape data. If not, then free the
        **  buffer and reallocate it at the larger size.
        */
        if (Background != NULL) {
            if (MouseShape->Get_Width() > Background->Get_Width() ||
                MouseShape->Get_Height() > Background->Get_Height()) {
 
                delete Background;
                Background = NULL;
            }
        }
        if (Alternate != NULL) {
            if (MouseShape->Get_Width() > Alternate->Get_Width() ||
                MouseShape->Get_Height() > Alternate->Get_Height()) {
 
                delete Alternate;
                Alternate = NULL;
            }
        }
        if (SidebarAlternate != NULL) {
            if (MouseShape->Get_Width() > SidebarAlternate->Get_Width() ||
                MouseShape->Get_Height() > SidebarAlternate->Get_Height()) {
 
                delete SidebarAlternate;
                SidebarAlternate = NULL;
            }
        }
 
        /*
        **  Allocate a new background buffer if necessary. This must be big enough to
        **  hold the largest sized shape from the currently assigned shape set data.
        */
        if (Background == NULL) {
            Background = new BSurface(MouseShape->Get_Width(), MouseShape->Get_Height(), SurfacePtr->Bytes_Per_Pixel());
        }
        if (Alternate == NULL) {
            Alternate = new BSurface(MouseShape->Get_Width(), MouseShape->Get_Height(), SurfacePtr->Bytes_Per_Pixel());
        }
        if (SidebarAlternate == NULL) {
            SidebarAlternate = new BSurface(MouseShape->Get_Width(), MouseShape->Get_Height(), SurfacePtr->Bytes_Per_Pixel());
        }
 
        return(Background != NULL && Alternate != NULL && SidebarAlternate != NULL);
    }
    return(false);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Matching_Rect -- Finds rectangle of current cursor position & size.           *
 *                                                                                             *
 *    This routine will return the logical rectangle that exactly encloses the cursor. This    *
 *    routine is typically used when drawing the cursor and manipulating the background buffer *
 *    under it.                                                                                *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the rectangle that surrounds the cursor.                              *
 *                                                                                             *
 * WARNINGS:   The rectangle is in logical coordinates. It may have to be biased to O/S        *
 *             coordinates if necessary.                                                       *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
Rect WWMouseClass::Matching_Rect(void) const
{
    Rect rect;
    if (Is_Data_Valid()) {
        ((WWMouseClass *)this)->Block_Mouse();
 
        /*
        **  Build the rectangle that the mouse shape will consume.
        */
        rect = MouseShape->Get_Rect(ShapeNumber);
        rect.X += MouseX - MouseXHot;
        rect.Y += MouseY - MouseYHot;
 
        ((WWMouseClass *)this)->Unblock_Mouse();
    }
    return(rect);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Save_Background -- Saves the background to a copy buffer.                     *
 *                                                                                             *
 *    This routine will save the region under the mouse (or where the mouse would appear at)   *
 *    to a copy buffer.                                                                        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   The previous contents of the copy buffer will be overwritten by this routine.   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Save_Background(void)
{
    if (Validate_Copy_Buffer()) {
 
        /*
        **  Build the rectangle that the mouse shape will consume.
        */
        SavedRegion = Matching_Rect();
 
        Rect rect = SavedRegion;
        rect.X += ConfiningRect.X;
        rect.Y += ConfiningRect.Y;
 
        /*
        **  Blit the background from the surface to the holding buffer.
        */
//      Rect old = SurfacePtr->Get_Rect();
//      SurfacePtr->Window.Reset();
        Background->Blit_From(Rect(0, 0, rect.Width, rect.Height), *SurfacePtr, rect);
//      SurfacePtr->Window.Set(old);
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Restore_Background -- Restores the image back where it came from.             *
 *                                                                                             *
 *    This is the counterpart routine to the Save_Background function. It will restore the     *
 *    image from the copy buffer back to the screen where it came from.                        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Restore_Background(void)
{
    if (SavedRegion.Is_Valid()) {
 
        Rect rect = SavedRegion;
        rect.X += ConfiningRect.X;
        rect.Y += ConfiningRect.Y;
 
        /*
        **  Blit the background from the holding buffer to the surface.
        */
//      Rect old = SurfacePtr->Get_Rect();
//      SurfacePtr->Window.Reset();
        SurfacePtr->Blit_From(rect, *Background, Rect(0, 0, rect.Width, rect.Height));
//      SurfacePtr->Window.Set(old);
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Draw_Mouse -- Manually draw the mouse to the surface specified.               *
 *                                                                                             *
 *    This is a kludge function that can be used to reduce mouse flicker. Normally the mouse   *
 *    must be hidden before an image is copied to the visible surface. By drawing the mouse    *
 *    in the correct position on the source image prior to the copy, the mouse doesn't need    *
 *    to be hidden and no mouse flicker occurs. This routine handles this manual draw process. *
 *                                                                                             *
 * INPUT:   surface  -- Pointer to the surface that the mouse will be drawn to.                *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   The destination surface is presumed to be the exact dimensions of the bouding   *
 *             rectangle specified in the mouse constructor. The call to Erase_Mouse must      *
 *             occur as soon as possible since the mouse is frozen until it is called.         *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Draw_Mouse(Surface * surface, bool issidebarsurface)
{
 
    BSurface *savesurface;
    Rect *savedregion;
    int xoffset;
    int yoffset;
 
    if (issidebarsurface){
        xoffset = -480;
        yoffset = 0;
        savesurface = SidebarAlternate;
        savedregion = &SidebarAltRegion;
    }else{
        xoffset = 0;
        yoffset = 0;
        savesurface = Alternate;
        savedregion = &AltRegion;
    }
 
    if (!Is_Hidden() && surface != NULL && surface != SurfacePtr && savesurface != NULL) {
        Block_Mouse();
 
        /*
        **  Blit the background from the surface to the holding buffer.
        */
        //Rect old = surface->Window.Get_Rect();
        //surface->Window.Reset();
        *savedregion = SavedRegion;
        savedregion->X += xoffset;
        savedregion->Y += yoffset;
        savesurface->Blit_From(Rect(0, 0, savedregion->Width, savedregion->Height), *surface, *savedregion);
        if (issidebarsurface){
            if (savedregion->X < 0 && -savedregion->X < Background->Get_Width()){
                Background->Blit_From(Rect(-savedregion->X, 0, savedregion->Width, savedregion->Height),
                                            *surface, Rect(0,savedregion->Y, savedregion->Width, savedregion->Height));
            }
        }else{
            Background->Blit_From(Rect(0, 0, savedregion->Width, savedregion->Height), *surface, *savedregion);
        }
        //surface->Window.Set(old);
        Raw_Draw_Mouse(surface, xoffset, yoffset);
        Unblock_Mouse();
    } else {
        savedregion->Width = 0;
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Erase_Mouse -- Restores the surface after a Draw_Mouse call.                  *
 *                                                                                             *
 *    This is the counterpart routine to Draw_Mouse. It will restore the specified surface     *
 *    back to its original state. The mouse is frozen between the calls to Draw_Mouse and      *
 *    Erase_Mouse, so it is imperative to call this routine at the first legal opportunity.    *
 *                                                                                             *
 * INPUT:   surface  -- Pointer to the surface that the mouse was previously drawn to.         *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Erase_Mouse(Surface * surface, bool issidebarsurface)
{
    if (!Is_Hidden() && surface != NULL && surface != SurfacePtr && Alternate != NULL && SidebarAlternate != NULL) {
 
        BSurface *savesurface;
        Rect savedregion;
 
        if (issidebarsurface){
            savesurface = SidebarAlternate;
            savedregion = SidebarAltRegion;
        }else{
            savesurface = Alternate;
            savedregion = AltRegion;
        }
 
        /*
        **  Blit the background from the holding buffer to the surface.
        */
        Block_Mouse();
        //Rect old = surface->Window.Get_Rect();
        //surface->Window.Reset();
        surface->Blit_From(savedregion, *savesurface, Rect(0, 0, savedregion.Width, savedregion.Height));
        //surface->Window.Set(old);
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Raw_Draw_Mouse -- Draws the mouse to the surface specified.                   *
 *                                                                                             *
 *    This will draw the mouse image to the surface specified. It does not do any checking     *
 *    except to make sure that the mouse image data is nominally valid.                        *
 *                                                                                             *
 * INPUT:   surface  -- The surface to draw the mouse upon.                                    *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   The background is not preserved by this routine.                                *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Raw_Draw_Mouse(Surface * surface, int xoffset, int yoffset)
{
    if (Is_Data_Valid() && surface != NULL) {
 
        /*
        **  Determine the rectangle that the mouse will be drawn
        **  to.
        */
 
        Rect rect = SavedRegion;
        rect.X += xoffset;
        rect.Y += yoffset;
//      if (surface == SurfacePtr) {
//          rect.X += ConfiningRect.X;
//          rect.Y += ConfiningRect.Y;
//      }
 
//      Rect old = surface->Get_Rect();
//      surface->Window.Reset();
        BSurface mdata(rect.Width, rect.Height, 1, MouseShape->Get_Data(ShapeNumber));
 
        if (surface == SurfacePtr) {
            Blit_Block(*surface, *NormalDrawer, mdata, Rect(0, 0, rect.Width, rect.Height), Point2D(rect.X, rect.Y), ConfiningRect);
        } else {
            Blit_Block(*surface, *NormalDrawer, mdata, Rect(0, 0, rect.Width, rect.Height), Point2D(rect.X, rect.Y), surface->Get_Rect());
        }
 
        //surface->Window.Set(old);
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Low_Show_Mouse -- Shows the mouse and saves the background.                   *
 *                                                                                             *
 *    This routine will save the background and then draw the mouse to the visible surface.    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Low_Show_Mouse(void)
{
    Block_Mouse();
    Save_Background();
    Raw_Draw_Mouse(SurfacePtr, 0, 0);
    Unblock_Mouse();
}
 
 
/***********************************************************************************************
 * WWMouseClass::Low_Hide_Mouse -- Restores the surface image in order to hide the mouse.      *
 *                                                                                             *
 *    This routine will hide the mouse on the visible surface. It does this by restoring the   *
 *    pixels under where the mouse was previously drawn.                                       *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Low_Hide_Mouse(void)
{
    Block_Mouse();
    Restore_Background();
    Unblock_Mouse();
}
 
 
/***********************************************************************************************
 * WWMouseClass::Show_Mouse -- Shows the mouse on the visible surface.                         *
 *                                                                                             *
 *    This routine is called when the mouse can be shown on the visible surface.               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Show_Mouse(void)
{
    if (!Is_Captured()) {
        ShowCursor(TRUE);
    } else {
        Block_Mouse();
        InterlockedIncrement(&MouseState);
        if (MouseState == 0) {
            Low_Show_Mouse();
        }
        assert(MouseState != 1);
        if (MouseState > 0) MouseState = 0;
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Hide_Mouse -- Hides the mouse from the visible surface.                       *
 *                                                                                             *
 *    This routine is called when the mouse is desired to be hidden from the visible surface.  *
 *    Typically, this must occur if the pixels where the mouse is located will be accessed.    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Hide_Mouse(void)
{
    if (!Is_Captured()) {
        ShowCursor(FALSE);
    } else {
        Block_Mouse();
        InterlockedDecrement(&MouseState);
        if (MouseState == -1) {
            Low_Hide_Mouse();
        }
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Capture_Mouse -- Capture the mouse into the mouse handler region.             *
 *                                                                                             *
 *    This routine will confine the mouse to the confining rectangle and take over drawing     *
 *    of the mouse image from the operating system. The typical state is to keep the mouse     *
 *    captured throughout the lifetime of the owning program.                                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Capture_Mouse(void)
{
    if (this != NULL && !Is_Captured()) {
        Block_Mouse();
        while (ShowCursor(FALSE) > -1) {}
        while (ShowCursor(TRUE) < -1) {}
        Hide_Mouse();
        IsCaptured = true;
 
        Show_Mouse();
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Release_Mouse -- Release the mouse back to the O/S.                           *
 *                                                                                             *
 *    This is the counterpart routine to Capture_Mouse. This routine will return the drawing   *
 *    and movement controls back to the operating system. Although the mouse will probably     *
 *    be able to roam outside the confining rectangle, the coordinates returned by this class  *
 *    are clipped to the confining rectangle anyway. This gives the impression that the mouse  *
 *    is still at a legal position. The presumption is that the mouse needs to be released to  *
 *    the O/S for reasons outside of the game itself. As such, the shouldn't detect any        *
 *    illegal mouse position.                                                                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   All mouse shape changes won't be relected while the mouse is released. The O/S  *
 *             handles drawing the mouse in that case.                                         *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Release_Mouse(void)
{
    if (this != NULL && Is_Captured()) {
        Block_Mouse();
        Hide_Mouse();
        IsCaptured = false;
        while (ShowCursor(FALSE) > -1) {}
        while (ShowCursor(TRUE) < -1) {}
        Show_Mouse();
 
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Conditional_Hide_Mouse -- Hides the mouse if it would overlap the region spec *
 *                                                                                             *
 *    This routine will hide the mouse if it lies within the region specified or if it moves   *
 *    within the region.                                                                       *
 *                                                                                             *
 * INPUT:   rect  -- The rectangle that the mouse should not be drawn within.                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Conditional_Hide_Mouse(Rect )
{
    Hide_Mouse();
}
 
 
/***********************************************************************************************
 * WWMouseClass::Conditional_Show_Mouse -- Releases the mouse hiding region tracking.          *
 *                                                                                             *
 *    This routine will release the region hiding tracking that was set up with a previous     *
 *    call to Conditional_Hide_Mouse().                                                        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Conditional_Show_Mouse(void)
{
    Show_Mouse();
}
 
 
/***********************************************************************************************
 * WWMouseClass::Convert_Coordinate -- Convert an O/S coordinate into a logical coordinate.    *
 *                                                                                             *
 *    Sometimes you come across system mouse coordinates and they need to be converted into    *
 *    game logical coordinates. This routine will perform this function.                       *
 *                                                                                             *
 * INPUT:   x,y   -- Reference to the coordinates that will be converted into game logical     *
 *                   coordinates.                                                              *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   The coordinates will be bound as well as transformed by the confining rectangle.*
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Convert_Coordinate(int & x, int & y) const
{
    /*
    **  Convert the mouse position to legal bounds.
    */
    x -= ConfiningRect.X;
    y -= ConfiningRect.Y;
    if (x < 0) x = 0;
    if (y < 0) y = 0;
    if (x >= ConfiningRect.Width) x = ConfiningRect.Width-1;
    if (y >= ConfiningRect.Height) y = ConfiningRect.Height-1;
}
 
 
/***********************************************************************************************
 * WWMouseClass::Get_Bounded_Position -- Fetches the mouse position from the O/S.              *
 *                                                                                             *
 *    Fetches the mouse coordinates from the O/S and converts them into logical coordinates.   *
 *                                                                                             *
 * INPUT:   x,y   -- Reference to the coordinates that will be set by this routine.            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Get_Bounded_Position(int & x, int & y) const
{
    /*
    ** Get the mouse's current real cursor position
    */
    POINT pt;
    GetCursorPos(&pt);          // get the current cursor position
    x = pt.x;
    y = pt.y;
    Convert_Coordinate(x, y);
}
 
 
/***********************************************************************************************
 * WWMouseClass::Update_Mouse_Position -- Updates the mouse position to match that specified.  *
 *                                                                                             *
 *    This routine will update the mouse to match the position speicifed.                      *
 *                                                                                             *
 * INPUT:   x,y   -- The coordinates to position the mouse (hot spot). The coordinates are     *
 *                   specified as logical not O/S relative.                                    *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Update_Mouse_Position(int x, int y)
{
    /*
    **  If the desired position is not the same as the current
    **  position, then hide the mouse, reposition it, then show
    **  the mouse.
    */
    Block_Mouse();
    if (x != MouseX || y != MouseY) {
        if (Is_Captured() && !Is_Hidden()) Low_Hide_Mouse();
        MouseX = x;
        MouseY = y;
        if (Is_Captured() && !Is_Hidden()) Low_Show_Mouse();
    }
    Unblock_Mouse();
}
 
 
/***********************************************************************************************
 * WWMouseClass::Process_Mouse -- Mouse processing callback routine.                           *
 *                                                                                             *
 *    This routine should be called periodically (recommended 15 times per second). It will    *
 *    examine the operating system mouse position and then update the visible mouse to match.  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   03/10/1997 JLB : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Process_Mouse(void)
{
    if (!Is_Blocked()) {
        Block_Mouse();
 
        /*
        ** Fetch and update the mouse position.
        */
        int x;
        int y;
        Get_Bounded_Position(x, y);
        Update_Mouse_Position(x, y);
        Unblock_Mouse();
    }
}
 
 
/***********************************************************************************************
 * WWMouseClass::Set_Mouse_XY -- Sets the cursor position                                      *
 *                                                                                             *
 *    This routine will convert the position passed into screen coordinates and tell Windows   *
 *    to position the mouse cursor there                                                       *
 *                                                                                             *
 * INPUT:   x and y in game coordinates                                                        *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/11/1997 BG : Created.                                                                 *
 *=============================================================================================*/
void WWMouseClass::Set_Mouse_XY( int x, int y )
{
    if (x < 0) x = 0;                   // clamp to game coordinates
    if (y < 0) y = 0;
    if (x >= ConfiningRect.Width) x = ConfiningRect.Width-1;
    if (y >= ConfiningRect.Height) y = ConfiningRect.Height-1;
 
    x += ConfiningRect.X;           // convert to screen coordinates
    y += ConfiningRect.Y;
 
    SetCursorPos( x, y );           // set the current cursor position
}