Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

393 lines
11 KiB

/*++
*
* 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);
}