|
|
/*++
* * WOW v1.0 * * Copyright (c) 1991, Microsoft Corporation * * WUCURSOR.C * WOW32 16-bit User API support * * History: * Created 07-Mar-1991 by Jeff Parsons (jeffpar)--*/
#include "precomp.h"
#pragma hdrstop
MODNAME(wucursor.c);
/*++
void ClipCursor(<lpRect>) LPRECT <lpRect>;
The %ClipCursor% function confines the cursor to the rectangle on the display screen given by the <lpRect> parameter. If a subsequent cursor position, given with the %SetCursorPos% function or the mouse, lies outside the rectangle, Windows automatically adjusts the position to keep the cursor inside. If <lpRect> is NULL, the cursor is free to move anywhere on the display screen.
<lpRect> Points to a %RECT% structure that contains the screen coordinates of the upper-left and lower-right corners of the confining rectangle.
This function does not return a value.
The cursor is a shared resource. An application that has confined the cursor to a given rectangle must free it before relinquishing control to another application.--*/
ULONG FASTCALL WU32ClipCursor(PVDMFRAME pFrame){ RECT t1, *p1; register PCLIPCURSOR16 parg16;
GETARGPTR(pFrame, sizeof(CLIPCURSOR16), parg16); p1 = GETRECT16(parg16->f1, &t1);
ClipCursor( p1 );
FREEARGPTR(parg16); RETURN(0);}
/*++
HCURSOR CreateCursor(<hInstance>, <nXhotspot>, <nYhotspot>, <nWidth>, <nHeight>, <lpANDbitPlane>, <lpXORbitPlane>) HANDLE <hInstance>; int <nXhotspot>; int <nYhotspot>; int <nWidth>; int <nHeight>; LPSTR <lpANDbitPlane>; LPSTR <lpXORbitPlane>;
The %CreateCursor% function creates a cursor that has specified width, height, and bit patterns.
<hInstance> Identifies an instance of the module creating the cursor.
<nXhotspot> Specifies the horizontal position of the cursor hotspot.
<nYhotspot> Specifies the vertical position of the cursor hotspot.
<nWidth> Specifies the width in pixels of the cursor.
<nHeight> Specifies the height in pixels of the cursor.
<lpANDbitPlane> Points to an array of bytes containing the bit values for the AND mask of the cursor. This can be the bits of a device-dependent monochrome bitmap.
<lpXORbitPlane> Points to an array of bytes containing the bit values for the XOR mask of the cursor. This can be the bits of a device-dependent monochrome bitmap.
The return value identifies the cursor if the function was successful. Otherwise, it is NULL.--*/
ULONG FASTCALL WU32CreateCursor(PVDMFRAME pFrame){ ULONG ul; register PCREATECURSOR16 parg16; int nWidth; int nHeight; int nPlanes; int nBitsPixel; DWORD nBytesAND; DWORD nBytesXOR; LPBYTE lpBitsAND; LPBYTE lpBitsXOR; int ScanLen16;
HANDLE h32; HAND16 h16; HAND16 hInst16;
GETARGPTR(pFrame, sizeof(CREATECURSOR16), parg16); hInst16 = parg16->f1; nWidth = INT32(parg16->f4); nHeight = INT32(parg16->f5);
nPlanes = 1; /* MONOCHROME BITMAP */ nBitsPixel = 1; /* MONOCHROME BITMAP */
/*
** Convert the AND mask bits */ ScanLen16 = (((nWidth*nBitsPixel)+15)/16) * 2 ; // bytes/scan in 16 bit world
nBytesAND = ScanLen16*nHeight*nPlanes;
GETVDMPTR(parg16->f6, nBytesAND, lpBitsAND);
/*
** Convert the XOR mask bits */ ScanLen16 = (((nWidth*nBitsPixel)+15)/16) * 2 ; // bytes/scan in 16 bit world
nBytesXOR = ScanLen16*nHeight*nPlanes;
GETVDMPTR(parg16->f7, nBytesXOR, lpBitsXOR);
h32 = (HANDLE)CreateCursor(HMODINST32(hInst16),INT32(parg16->f2), INT32(parg16->f3), nWidth, nHeight, lpBitsAND, lpBitsXOR);
if (h32) { h16 = (HAND16)W32Create16BitCursorIcon(hInst16, INT32(parg16->f2), INT32(parg16->f3), nWidth, nHeight, nPlanes, nBitsPixel, lpBitsAND, lpBitsXOR, nBytesAND, nBytesXOR);
ul = SetupCursorIconAlias(hInst16, h32, h16, HANDLE_TYPE_CURSOR, NULL, (WORD)NULL); } else { ul = 0; }
FREEARGPTR(parg16); RETURN(ul);}
/*++
BOOL DestroyCursor(<hCursor>) HCURSOR <hCursor>;
The %DestroyCursor% function destroys a cursor that was previously created by the %CreateCursor% function and frees any memory that the cursor occupied. It should not be used to destroy any cursor that was not created with the %CreateCursor% function.
<hCursor> Identifies the cursor to be destroyed. The cursor must not be in current use.
The return value is TRUE if the function was successful. It is FALSE if the function failed.--*/
ULONG FASTCALL WU32DestroyCursor(PVDMFRAME pFrame){ ULONG ul; register PDESTROYCURSOR16 parg16;
GETARGPTR(pFrame, sizeof(DESTROYCURSOR16), parg16);
if (ul = GETBOOL16(DestroyCursor(HCURSOR32(parg16->f1)))) FREEHCURSOR16(parg16->f1);
FREEARGPTR(parg16); RETURN(ul);}
/*++
HCURSOR SetCursor(<hCursor>) HCURSOR <hCursor>;
The %SetCursor% function sets the cursor shape to the shape specified by the <hCursor> parameter. The cursor is set only if the new shape is different from the current shape. Otherwise, the function returns immediately. The %SetCursor% function is quite fast if the cursor identified by the <hCursor> parameter is the same as the current cursor.
If <hCursor> is NULL, the cursor is removed from the screen.
<hCursor> Identifes the cursor resource. The resource must have been loaded previously by using the %LoadCursor% function.
The return value identifies the cursor resource that defines the previous cursor shape. It is NULL if there is no previous shape.
The cursor is a shared resource. A window that uses the cursor should set the shape only when the cursor is in its client area or when it is capturing all mouse input. In systems without a mouse, the window should restore the previous cursor shape before the cursor leaves the client area or before the window relinquishes control to another window.
Any application that needs to change the shape of the cursor while it is in a window must make sure the class cursor for the given window's class is set to NULL. If the class cursor is not NULL, Windows restores the previous shape each time the mouse is moved.--*/
ULONG FASTCALL WU32SetCursor(PVDMFRAME pFrame){ ULONG ul; register PSETCURSOR16 parg16;
GETARGPTR(pFrame, sizeof(SETCURSOR16), parg16);
ul = GETHCURSOR16(SetCursor( HCURSOR32(parg16->f1) ));
FREEARGPTR(parg16); RETURN(ul);}
/*++
void SetCursorPos(<X>, <Y>) int <X>; int <Y>;
The %SetCursorPos% function moves the cursor to the screen coordinates given by the <X> and <Y> parameters. If the new coordinates are not within the screen rectangle set by the most recent %ClipCursor% function, Windows automatically adjusts the coordinates so that the cursor stays within the rectangle.
<X> Specifies the new x-coordinate (in screen coordinates) of the cursor.
<Y> Specifies the new <y>-coordinate (in screen coordinates) of the cursor.
This function does not return a value.
The cursor is a shared resource. A window should move the cursor only when the cursor is in its client area.--*/
ULONG FASTCALL WU32SetCursorPos(PVDMFRAME pFrame){ register PSETCURSORPOS16 parg16;
GETARGPTR(pFrame, sizeof(SETCURSORPOS16), parg16);
SetCursorPos( INT32(parg16->f1), INT32(parg16->f2) );
FREEARGPTR(parg16); RETURN(0);}
/*++
int ShowCursor(<fShow>) BOOL <fShow>;
The %ShowCursor% function shows or hides the cursor. When the %ShowCursor% function is called, an internal display counter is incremented by one if the <fShow> parameter is TRUE, or decremented by one if the <fShow> parameter is FALSE. If the internal display counter is greater then or equal to zero, the cursor is displayed. If the counter is less then zero, the cursor is hidden. Calls to the %ShowCursor% function are accumulative: for each call to hide the cursor, a corresponding call must be made to show the cursor.
<fShow> Specifies whether the display count is to be increased or decreased. The display count is increased if fShow is TRUE. Otherwise, it is decreased.
The return value specifies the new display count.
When Windows is first started, the display count is zero if a mouse is installed or -1 if no mouse is installed.
The cursor is a shared resource. A window that hides the cursor should show the cursor before the cursor leaves its client area, or before the window relinquishes control to another window.--*/
ULONG FASTCALL WU32ShowCursor(PVDMFRAME pFrame){ ULONG ul; register PSHOWCURSOR16 parg16;
GETARGPTR(pFrame, sizeof(SHOWCURSOR16), parg16);
ul = GETINT16(ShowCursor( BOOL32(parg16->f1) ));
FREEARGPTR(parg16); RETURN(ul);}
//**************************************************************************
// This handles both LoadIcon and LoadCursor
//
//**************************************************************************
ULONG FASTCALL WU32LoadCursor(PVDMFRAME pFrame){ ULONG ul = 0; PSZ psz2; LPBYTE pResData = NULL; register PLOADCURSOR16 parg16; BOOL fIsCursor; HAND16 hInst16; HAND16 hRes16;
LPWSTR lpUniName_CursorIcon;
GETARGPTR(pFrame, sizeof(LOADCURSOR16), parg16); GETPSZIDPTR(parg16->f2, psz2); GETMISCPTR (parg16->f3, pResData);
fIsCursor = ((WORD)parg16->f7 == (WORD)RT_CURSOR); hInst16 = FETCHWORD(parg16->f1); hRes16 = parg16->f5;
if (HIWORD(psz2) != (WORD) NULL) { if (!(MBToWCS(psz2, -1, &lpUniName_CursorIcon, -1, TRUE))) { FREEMISCPTR(pResData); FREEPSZIDPTR(psz2); FREEARGPTR(parg16); RETURN(ul); } } else { lpUniName_CursorIcon = (LPWSTR)psz2; }
ul = (ULONG) (pfnOut.pfnServerLoadCreateCursorIcon)(HINSTRES32(hInst16), (LPTSTR) NULL, // pszModName unused by user32
parg16->f6, (LPCTSTR) lpUniName_CursorIcon, parg16->f4, pResData, (LPTSTR) parg16->f7, 0);
if (ul) ul = SetupResCursorIconAlias(hInst16, (HAND32)ul, psz2, hRes16, fIsCursor ? HANDLE_TYPE_CURSOR : HANDLE_TYPE_ICON);
if (HIWORD(psz2) != (WORD) NULL) { LocalFree (lpUniName_CursorIcon); }
FREEMISCPTR(pResData); FREEPSZIDPTR(psz2); FREEARGPTR(parg16); RETURN(ul);}
|
