paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-04 05:39:29 +01:00
Code Issues Packages Projects Releases Wiki Activity
c26348a3dd
fpc/rtl/os2/moucalls.pas
Jonas Maebe e5a1231931 * updated FSF address (mantis #30198, patch by Paul Gevers) 
git-svn-id: trunk@34598 -
2016-10-02 12:56:59 +00:00

1089 lines
48 KiB
ObjectPascal
Raw Blame History

{Set tabsize to 4.}
{****************************************************************************
MOUCALLS interface unit
Free Pascal Runtime Library for OS/2
Copyright (c) 1999-2000 by Florian Kl„mpfl
Copyright (c) 1999-2000 by Daniel Mantione
Copyright (c) 1999-2000 by Tomas Hajny
The Free Pascal runtime library is distributed under the Library GNU Public
License v2. So is this unit. The Library GNU Public License requires you to
distribute the source code of this unit with any product that uses it.
Because the EMX library isn't under the LGPL, we grant you an exception to
this, and that is, when you compile a program with the Free Pascal Compiler,
you do not need to ship source code with that program, AS LONG AS YOU ARE
USING UNMODIFIED CODE! If you modify this code, you MUST change the next
line:
<This is an official, unmodified Free Pascal source code file.>
Send us your modified files, we can work together if you want!
Free Pascal 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
Library GNU General Public License for more details.
You should have received a copy of the Library GNU General Public License
along with Free Pascal; see the file COPYING.LIB. If not, write to
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
****************************************************************************}
unit MouCalls;
{ Interface library to MOUCALLS.DLL (through EMXWRAP.DLL; C calling convention
- cdecl - must be used for EMXWRAP, whereas direct MOUCALLS calls would need
16-bit Pascal calling convention with thunking instead).
Variant records and aliases for some record types created to maintain highest
possible level of compatibility with other existing OS/2 compilers.
Changelog:
People:
TH - Tomas Hajny (xhajt03@mbox.vol.cz on Internet)
Date: Description of change: Changed by:
- First released version 1.0 TH
Coding style:
I have tried to use the same coding style as Daniel Mantione in unit
DOSCALLS, although I can't say I would write it the same way otherwise
(I would write much more spaces myself, at least). Try to use it as well,
please. Original note by Daniel Mantione follows:
It may be well possible that coding style feels a bit strange to you.
Nevertheless I friendly ask you to try to make your changes not look all
to different. To make life easier, set your IDE to use tab characters,
turn optimal fill, autoindent and backspace unindents on and set a
tabsize of 4.}
{***************************************************************************}
interface
{***************************************************************************}
{$IFDEF FPC}
{$PACKRECORDS 1}
{$ENDIF FPC}
const
{return codes / error constants (those marked with * shouldn't occur under
normal conditions)}
NO_ERROR = 0;
Error_Invalid_Parameter = 87;
ERROR_SEM_TIMEOUT =121;
ERROR_MOUSE_NO_DEVICE =385;
ERROR_MOUSE_INV_HANDLE =386; {*}
ERROR_MOUSE_INV_PARMS =387;
ERROR_MOUSE_CANT_RESET =388; {*}
ERROR_MOUSE_DISPLAY_PARMS =389; {*}
ERROR_MOUSE_INV_MODULE =390;
ERROR_MOUSE_INV_ENTRY_PT =391; {*}
ERROR_MOUSE_INV_MASK =392; {*}
NO_ERROR_MOUSE_NO_DATA =393;
NO_ERROR_MOUSE_PTR_DRAWN =394; {*}
ERROR_MOUSE_SMG_ONLY =412;
ERROR_MOUSE_INVALID_ASCIIZ =413;
ERROR_MOUSE_INVALID_MASK =414;
ERROR_MOUSE_REGISTER =415;
ERROR_MOUSE_DEREGISTER =416;
ERROR_MOUSE_INVALID_IOWAIT =435; {*}
ERROR_MOU_DETACHED =466;
ERROR_MOUSE_NO_CONSOLE =501;
ERROR_MOUSE_INVALID_HANDLE =502; {*}
ERROR_MOU_EXTENDED_SG =505;
ERROR_MOU_NOT_INITIALIZED =530; {*}
ERROR_MOUINITREAL_DONE =531; {*}
ERROR_MOUSE_CALLER_NOT_SUBSYS =533; {*}
{constants for FnMask in MouRegister}
MR_MOUGETNUMBUTTONS =$00000001;
MR_MOUGETNUMMICKEYS =$00000002;
MR_MOUGETDEVSTATUS =$00000004;
MR_MOUGETNUMQUEEL =$00000008;
MR_MOUREADEVENTQUE =$00000010;
MR_MOUGETSCALEFACT =$00000020;
MR_MOUGETEVENTMASK =$00000040;
MR_MOUSETSCALEFACT =$00000080;
MR_MOUSETEVENTMASK =$00000100;
MR_MOUOPEN =$00000800;
MR_MOUCLOSE =$00001000;
MR_MOUGETPTRSHAPE =$00002000;
MR_MOUSETPTRSHAPE =$00004000;
MR_MOUDRAWPTR =$00008000;
MR_MOUREMOVEPTR =$00010000;
MR_MOUGETPTRPOS =$00020000;
MR_MOUSETPTRPOS =$00040000;
MR_MOUINITREAL =$00080000;
MR_MOUSETDEVSTATUS =$00100000;
{constants for mouse hot key bits in MouGetHotKey/MouSetHotKey}
MHK_BUTTON1 =1;
MHK_BUTTON2 =2;
MHK_BUTTON3 =4;
{MouGetDevStatus/MouSetDevStatus device status constants}
MOUSE_QUEUEBUSY =$0001; {event queue busy with I/O}
MOUSE_BLOCKREAD =$0002; {block read in progress}
MOUSE_FLUSH =$0004; {flush in progress}
MOUSE_UNSUPPORTED_MODE =$0008; {pointer draw routine disabled}
{by unsupported mode }
MOUSE_DISABLED =$0100; {drawing operations for pointer}
{draw routine are disabled }
MOUSE_MICKEYS =$0200; {mouse data returned in mickeys, not pels}
{constants for WaitFlag in MouReadEventQue and MouSynch}
MOU_NOWAIT =$0000; {MouReadEventQue: don't wait for data }
{ on empty queue (return a null record)}
{MouSynch: control immediately}
{ returned to requestor }
MOU_WAIT =$0001; {MouReadEventQue: wait for data on empty queue}
{MouSynch: requestor waits until}
{ mouse device driver is free }
{constants for MouGetEventMask/MouSetEventMask events}
MOUSE_MOTION =$0001; {report mouse motion events with}
{no button press/release events }
MOUSE_MOTION_WITH_BN1_DOWN =$0002; {report button 1 press/release}
{events, with mouse motion }
MOUSE_BN1_DOWN =$0004; {report button 1 press/release}
{events, without mouse motion }
MOUSE_MOTION_WITH_BN2_DOWN =$0008; {report button 2 press/release}
{events, with mouse motion }
MOUSE_BN2_DOWN =$0010; {report button 2 press/release}
{events, without mouse motion }
MOUSE_MOTION_WITH_BN3_DOWN =$0020; {report button 3 press/release}
{events, with mouse motion }
MOUSE_BN3_DOWN =$0040; {report button 3 press/release}
{events, without mouse motion }
{constants for Status in MouSetDevStatus}
MOU_DRAW =0;
MOU_NODRAW =1;
MOU_PELS =0;
MOU_MICKEYS =2;
type
{unnecessary, just FYI}
THMOU=word;
PHMOU=^THMOU;
{record type for MouGetPtrPos/MouSetPtrPos}
TPtrLoc=record
Row, {mouse pointer row coordinate (in pels or characters)}
Col:word; {mouse pointer column coordinate (in pels or characters)}
end;
PPtrLoc=^TPtrLoc;
PtrLoc=TPtrLoc;
{record type for MouGetPtrShape/MouSetPtrShape}
TPtrShape=record
cb, {length of image buffer in bytes}
Col, {pointer width in characters (in text}
{modes; always 1) or pixels (>= 1) }
Row, {pointer height in characters (in text}
{modes; always 1) or pixels (>=1) }
ColHot, {hotspot offset from the left}
{side, in characters or pels }
{(must be 0 in text modes) }
RowHot:word; {hotspot offset from the top,}
{in characters or pels }
{(must be 0 in text modes) }
end;
PPtrShape=^TPtrShape;
PtrShape=TPtrShape;
{record type for MouReadEventQue}
(* #pragma pack(2) ??? *)
TMouEventInfo=record
fs:word; {event bits (state of the mouse at the time }
{of the event) - see MOUSE_MOTION, }
{MOUSE_MOTION_WITH_BN1_DOWN, MOUSE_BN1_DOWN, }
{MOUSE_MOTION_WITH_BN2_DOWN, MOUSE_BN2_DOWN, }
{MOUSE_MOTION_WITH_BN3_DOWN and MOUSE_BN3_DOWN }
{constants (other bits reserved and set to zero)}
Time:cardinal; {event timestamp - unique number of milliseconds}
{(since the system was started }
Row, {pointer current row position (absolute or relative)}
Col:integer; {pointer current column position}
{(absolute or relative) }
end;
PMouEventInfo=^TMouEventInfo;
MouEventInfo=TMouEventInfo;
{record type for MouGetNumQueEl}
TMouQueInfo=record
cEvents, {current number of elements in event}
{queue, between 0 and cmaxEvents }
cmaxEvents:word; {maximum queue size in elements, as specified }
{in the QSIZE=NN parameter in DEVICE=MOUSExxx.SYS}
{statement in CONFIG.SYS }
end;
PMouQueInfo=^TMouQueInfo;
MouQueInfo=TMouQueInfo;
{record type for MouGetScaleFact/MouSetScaleFact}
TScaleFact=record
RowScale, {current row scaling factor}
ColScale:word; {current column scaling factor}
end;
PScaleFact=^TScaleFact;
ScaleFact=TScaleFact;
{record type for MouRemovePtr}
TNoPtrRect=record
Row, {upper row of the rectangle (pels or characters)}
Col, {column of the left edge (pels or characters)}
cRow, {bottom row of the rectangle (pels or characters)}
cCol:word; {column of the right edge (pels or characters)}
end;
PNoPtrRect=^TNoPtrRect;
NoPtrRect=TNoPtrRect;
TThreshold=record
case boolean of
false:(Length:word; {length of data in bytes}
Level1, {first movement level}
Lev1Mult, {first level multiplier}
Level2, {second movement level}
Lev2Mult:word); {second level multiplier}
true:(aLength:word);
end;
PThreshold=^TThreshold;
Threshold=TThreshold;
{Register a mouse subsystem within a session.}
{ModuleName is name of the dynamic link module (the maximum length
is 8 characters - plus the final #0 character in the PChar version of this
call), ProcName is the dynamic link entry point name of a routine that receives
control when any of the registered functions are called (the maximum length
is 32 bytes - plus the final #0 character in the PChar version of this call),
FnMask is a mask of bits, where each bit set to 1 identifies a mouse function
being registered - see MR_MOU* constants.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
413 ERROR_MOUSE_INVALID_ASCIIZ
414 ERROR_MOUSE_INVALID_MASK
415 ERROR_MOUSE_REGISTER
466 ERROR_MOU_DETACHED
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The Base Mouse Subsystem is the default mouse subsystem. There can be only
one MouRegister outstanding for each session without an intervening
MouDeRegister. MouDeRegister must be issued by the same process that issued
MouRegister.
* When any registered function is called, control is routed to EntryName.
When this routine is entered, four additional values are pushed onto the
stack. The first is the index number (Word) of the function being called.
The second is a near pointer (Word). The third is the caller's DS register
(Word). The fourth is the return address (DWord) to the mouse router. For
example, if MouGetNumMickeys were called and control routed to EntryName,
the stack would appear as if the following instructions were executed:
PUSH@ WORD MickeyCnt
PUSH WORD MouHandle
CALL FAR MouGetNumMickeys
PUSH WORD Function Code
CALL NEAR Entry point in Mouse Router
PUSH DS
CALL FAR EntryName
* When a registered function returns to the Mouse Router, AX is interpreted
as follows:
AX = 0 - no error, do not invoke the Base Mouse Subsystem routine,
return AX = 0
AX = -1 - invoke the BaseMouse Subsystem routine, return AX = return code
from the Base Mouse Subsystem
AX = error (if not 0 or -1) - do not invoke the Base Mouse Subsystem
Routine, return AX = error
* When the mouse router receives a mouse call, it routes it to the Base Mouse
Subsystem unless an application or other mouse subsystem has previously
issued MouRegister for that call. If the call was registered, the subsystem
is entered at the EntryName specified, and provided with the applicable
function code.
* The registered function mask is used to determine whether a requested
function is performed by the registered mouse subsystem or default to the
Base Mouse Subsystem.
* The following list shows the relationship of the mouse API calls and the
Function Code passed to either the Base Mouse Subsystem or a registered
mouse subsystem.
MOU API calls Function Code
MouGetNumButtons 00h
MouGetNumMickeys 01h
MouGetDevStatus 02h
MouGetNumQueEl 03h
MouReadEventQue 04h
MouGetScaleFact 05h
MouGetEventMask 06h
MouSetScaleFact 07h
MouSetEventMask 08h
Reserved 09h
Reserved 0Ah
MouOpen 0Bh
MouClose 0Ch
MouGetPtrShape 0Dh
MouSetPtrShape 0Eh
MouDrawPtr 0Fh
MouRemovePtr 10h
MouGetPtrPos 11h
MouSetPtrPos 12h
MouInitReal 13h
MouFlushQue 14h
MouSetDevStatus 15h
* A registered mouse sybsystem must leave the stack, on exit, in the exact
state it was received.}
function MouRegister(ModuleName,ProcName:PChar;FnMask:cardinal):word; cdecl;
function MouRegister(ModuleName,ProcName:string;FnMask:cardinal):word;
{Deregister a mouse subsystem previously registered within a session.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
416 ERROR_MOUSE_DEREGISTER
466 ERROR_MOU_DETACHED
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The process that issued the MouRegister must release the session
(by a MouDeRegister call) from the registered subsystem before another PID
may issue MouRegister.
* The process that issued the MouRegister is the only process that may
issue MouDeRegister against the currently registered subsystem.
* After the owning process has released the subsystem with a MouDeRegister
call, any other process in the session may issue a MouRegister and therefore
modify the mouse support for the entire session.}
function MouDeRegister:word; cdecl;
{Direct the mouse driver to flush (empty) the mouse event queue and the monitor
chain data for the session.}
{MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
function MouFlushQue(MouHandle:word):word; cdecl;
{Query the mouse driver to determine the current row and column coordinate
position of the mouse pointer.}
{Mouse pointer position returned in MouPtr, MouHandle is the mouse device
handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* For a text window (VIO) application, the text window is a view on the
larger logical video buffer (LVB). The mouse pointer can be outside that
view and still be within the extent of the LVB. MouGetPtrPos then returns
the coordinates of the cell under the mouse pointer. If the pointer is
outside the LVB image extent, the coordinates of the nearest LVB cell are
returned. In either case, the LVB is scrolled until the reported LVB cell
appears within the view window.}
function MouGetPtrPos(var MouPtr:TPtrLoc;MouHandle:word):word; cdecl;
{Direct the mouse driver to set a new row and column coordinate position for
the mouse pointer.}
{MouPtr contains the new pointer coordinates, MouHandle is the mouse device
handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The application must ensure that the coordinate position specified conforms
to the current display mode orientation for the session. Pel values must
be used for graphics modes and character values for text modes.
* This function has no effect on the display's current collision area
definition as specified by the MouDrawPtr call. If the mouse pointer image
is directed into a defined collision area, the pointer image is not drawn
until either the pointer is moved outside the collision area or the collision
area is released by the MouDrawPtr call.}
function MouSetPtrPos(const MouPtr:TPtrLoc;MouHandle:word):word; cdecl;
{Set the pointer shape and size to be used as the mouse device pointer image
for all applications in a session.}
{ImageBuf contains the bit image used by the mouse device driver as the pointer
shape for that session. The buffer consists of AND and XOR pointer masks
in a format meaningful to the pointer draw device driver (see remarks bellow),
ImageInfo contains the necessary data for the pointer draw device driver to
build a row-by-column image for each bit plan for the current display mode,
MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* An application passes a data image to the mouse device driver that the mouse
driver applies to the screen whenever the logical pointer position is not
located in the application-defined collision area. The application
synchronizes use of the screen with the mouse driver by way of MouRemovePtr
and MouDrawPtr.
* The pointer shape is dependent on the display device driver used to support
the display device. OS/2 supports text and graphics modes. These modes are
restricted to modes 0 through 7, depending on the display device. Character
modes (modes 0, 1, 2, 3, and 7) support the pointer cursor only as a reverse
block character. This reverse block character has a character height
and width equal to 1.
* The pointer shape is mapped by the Pointer Draw Device Driver and determined
completely by the application. The height and width may vary from 1 through
the pel size of the display screen. For restrictions concerning the Pointer
Draw Device Driver, see IBM Operating System/2 Version 1.2 I/O Subsystems And
Device Support Volume 1.
* For CGA compatible text modes (0, 1, 2, and 3) the following describes
the AND and XOR pointer mask bit definitions for each character cell
of the masks. Bit values are:
Bit Description
15 Blinking
14-12 Background color
11 Intensity
10-8 Foreground color
7-0 Character
* For other custom displays and for the extended modes of the EGA attachment,
it is possible to set the display to modes that require multiple bit planes.
In these cases, the area sized by the row and column limits must be repeated
for each bit plane supported in that mode. Consequently, the calling process
must supply enough data to allow the mouse device driver to draw the pointer
shape on all currently supported bit planes in that session. For text modes,
row and column offset must equal 0.}
function MouSetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
function MouSetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
{Get (copy) the mouse pointer shape for the session.}
{The pointer bit image is returned in ImageBuf (see MouSetPtrShape description
for information about the resulting content of this buffer), the size of the
pointer image buffer must be supplied in ImageInfo.cb (if the value is too
small, the true length is placed in this field and an error is returned),
on return, ImageInfo is filled with mouse pointer information, MouHandle is
the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The application passes a parameter list with the same meaning as defined
for MouSetPtrShape to the mouse device driver. The mouse device driver
copies the parameters that describe the pointer shape and attributes into
the pointer definition control block pointed to by the PtrDefRec parameter.
The word 0 (buffer length = cb) pointer definition record parameter field
must contain the size in bytes of the application buffer where the device
driver is to insert the session's pointer image. All other words in
the parameter list are returned to the application by MouGetPtrShape.
* For all OS/2 system-supported modes, size of the pointer image buffer
is specified in bytes and is equal to:
1) Mono & Text Modes:
For text mode, height and width must be 1, so length is always 4.
size = (height in chars) * (width in chars) * 2 * 2 = 1 * 1 * 2 * 2 = 4
2) Graphics Mode:
Width-in-pels must be a multiple of 8.
size = (height in pels) * (width in pels) * (bits per pel) * 2 / 8
a) Modes 4 and 5 (320 X 200)
size = (height) * (width) * 2 * 2 / 8
b) Mode 6 (640 X 200)
size = (height) * (width) * 1 * 2 / 8
* If the buffer size is insufficient, the cb field contains the actual size
in bytes of the returned pointer image.
* The pointer shape may be set by the application with MouSetPtrShape or may
be the default image provided by the installed Pointer Device Driver.}
function MouGetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
function MouGetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
{Return status flags for the installed mouse device driver.}
{The current status flag settings for the installed mouse device driver are
returned in Status - see MOUSE_QUEUEBUSY, MOUSE_BLOCKREAD, MOUSE_FLUSH,
MOUSE_UNSUPPORTED_MODE, MOUSE_DISABLED and MOUSE_MICKEYS constants (other bits
are reserved and set to zero), MouHandle is the mouse device handle from
a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
function MouGetDevStatus(var Status:word;MouHandle:word):word; cdecl;
{Return the number of buttons supported on the installed mouse driver.}
{Number of physical buttons (1..3) returned in ButtonCount, MouHandle is
the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
function MouGetNumButtons(var ButtonCount:word;MouHandle:word):word; cdecl;
{Return the number of mickeys in each centimeter for the installed mouse
driver.}
{Number of physical mouse motion units (mickeys) in each centimeter (a constant
based upon the attached mouse device) returned in MickeyCnt, MouHandle is
the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
function MouGetNumMickeys(var MickeyCnt:word;MouHandle:word):word; cdecl;
{Read an event from the mouse device FIFO event queue.}
{The mouse event queue is returned in Event, WaitFlag determines the action to
take when MouReadEventQue is issued and no event is available (the mouse event
queue is empty) - see MOU_NOWAIT and MOU_WAIT constants, MouHandle is the mouse
device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
393 ERROR_MOUSE_NO_DATA
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The types of queued events are directly affected by the current value of
the Mouse EventMask. MouSetEventMask is used to indicate the types of events
desired, and MouGetEventMask is used to query the current value of the mask.
Refer to these functions for further explanation of the masking of events.
Recognition of the mouse transition depends on the use of MouState returned
in the event record. The application should focus on bit transitions that
occur in this word. It is important to properly set the event mask with
MouSetEventMask for reporting the state transitions.
Event.fs reports the state of the mouse that resulted from the action that
caused the event. The action can be pressing or releasing a button, and/or
moving the mouse. All status is given, regardless of the EventMask that
was used to determine whether or not to report the event.
For example, assume the EventMask indicates that the application wishes only
button 1 events. The EventMask has only bits 1 and 2 set in this case. Also
assume the current state of the mouse is no buttons down, and mouse is not
moving. At this point, button 1 is pressed causing an event; the status shows
button 1 down (bit 2 set). Next the mouse is moved, thereby causing more
events; status shows bit 1 set. Finally, mouse is stopped and button 1 is
released. The event shows status with no bits set.
Next, button 2 is pressed. No event occurs. Mouse is then moved; again,
no event. Then, while mouse is still in motion, button 1 is pressed; an event
is generated with bits 1 and 3 set in the state word. While mouse is still
in motion, both buttons are released. Because button 1 changes states,
an event occurs. The state word has bit 0 set. Finally, mouse is stopped.
No event occurs, again because no button 1 transition has taken place.
* The Event.Row and Event.Col fields may contain either absolute display
coordinates or relative mouse motion in mickeys. See MouSetDevStatus for
additional information.}
function MouReadEventQue(var Event:TMouEventInfo;var WaitFlag:word;
MouHandle:word):word; cdecl;
{Return the current status for the mouse device driver event queue.}
{Mouse queue status returned in MouseQInfo, MouHandle is the mouse device
handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
function MouGetNumQueEl(var MouseQInfo:TMouQueInfo;MouHandle:word):word; cdecl;
{Return the current value of the mouse event queue mask.}
{The current mouse device driver's event mask (as previously set by
MouSetEventMask call) is returned in EventMask - see MOUSE_MOTION,
MOUSE_MOTION_WITH_BN1_DOWN, MOUSE_BN1_DOWN, MOUSE_MOTION_WITH_BN2_DOWN,
MOUSE_BN2_DOWN, MOUSE_MOTION_WITH_BN3_DOWN and MOUSE_BN3_DOWN constants (other
bits are reserved and set to zero, MouHandle is the mouse device handle from
a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* Buttons are logically numbered from left to right.}
function MouGetEventMask(var EventMask:word;MouHandle:word):word; cdecl;
{Assign a new event mask to the current mouse device driver.}
{EventMask contains the mask indicating what mouse events are to be placed on
the event queue (see MouReadEventQue) and which events are to be ignored - see
MOUSE_MOTION, MOUSE_MOTION_WITH_BN1_DOWN, MOUSE_BN1_DOWN,
MOUSE_MOTION_WITH_BN2_DOWN, MOUSE_BN2_DOWN, MOUSE_MOTION_WITH_BN3_DOWN and
MOUSE_BN3_DOWN constants (other bits reserved and set to zero; a bit set to
zero means that the associated type of event is not reported to the
application, mouse buttons are always numbered from left to right - when the
mouse is properly positioned for use, the left-hand button is button 1),
MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* Setting a bit in the event mask means that the associated event is reported
on the mouse FIFO event queue. See MouReadEventQue for examples of event
mask use.}
function MouSetEventMask(var EventMask:word;MouHandle:word):word; cdecl;
{Return scaling factors for the current mouse device (a pair of 1-word
values).}
{Current row and column coordinate scaling factors (1 <= factor <= 32767)
returned in Scale (see MouSetScaleFact for more information), MouHandle is
the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The units of the scale factor depend on the mode of the display screen
for the session. If the screen is operating in text mode, the scaling units
are relative to characters. If the screen is operating in graphics mode,
the scaling units are relative to pels.}
function MouGetScaleFact(var Scale:TScaleFact;MouHandle:word):word; cdecl;
{Assign to the current mouse device driver a new pair of 1-word scaling
factors.}
{Scale contains the new row and column coordinate scaling factors (1 <= factor
<= 32767), MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouSetScaleFact sets the mickey-to-pixel ratio for mouse motion. The row
scale and column scale ratios specify a number of mickeys for each 8 pixels.
The default value for the row scale is 16 mickeys for each 8 pixels. The
default value for the column scale is 8 mickeys to 8 pixels.
* The number of pixels moved does not have to correspond 1-to-1 with the number
of mickeys the mouse moves. The scaling factor defines a sensitivity
for the mouse that is a ratio of the number of mickeys required to move
the cursor 8 pixels on the screen. The sensitivity determines at what rate
the cursor moves on the screen.}
function MouSetScaleFact(const Scale:TScaleFact;MouHandle:word):word; cdecl;
{Open the mouse device for the current session.}
{DriverName contains the name of the pointer draw device driver to be used as
the pointer-image drawing routine for this session (such device driver must be
included in the CONFIG.SYS file at system start-up time) or is nil (the default
pointer draw device driver supplied by the system is used then), mouse device
handle is returned in MouHandle.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
390 ERROR_MOUSE_INV_MODULE_PT
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouOpen initializes the mouse functions to a known state. The application
may have to issue additional mouse functions to establish the environment
it desires. For example, after the MouOpen, the collision area is defined
to be the size of the entire display. Therefore, to get the pointer to be
displayed, the application must issue a MouDrawPtr to remove the collision
area.
* The state of the mouse after the first MouOpen is:
- Row/Col scale factors set to 16/8 (see MouSetScaleFact)
- all events reported (see MouSetEventMask)
- empty event queue (see MouReadEventQue and MouGetNumQueEl)
- all user settable Device Status bits reset (set to zero;
see MouSetDevStatus)
- pointer set to center of screen if valid display mode is set (see
MouSetPtrPos)
- pointer shape set to the default for the pointer device driver currently
registered in the session (see MouSetPtrShape)
- collision area equal to full screen (see MouDrawPtr and MouRemovePtr)
* DriverName has a different definition when the caller is the Base Video
Subsystem (BVS). However, this implies direct calling of the 16-bit routine,
which is not supported currently. In such case the selector portion
of the pointer is zero, the offset portion is non-zero and contains a display
configuration number (sequentially numbered where 1 is the first display
configuration). The MouOpen call issued by BVS is executed on the VioSetMode
path. Using the display configuration number passed on the MouOpen call, the
Base Mouse Subsystem can detect a change in display configurations. This form
of the MouOpen call is not recommended for applications. Applications should
either send the name of the pointer draw device driver or nil.}
function MouOpen(DriverName:PChar;var MouHandle:word):word; cdecl;
function MouOpen(DriverName:string;var MouHandle:word):word;
{Close the mouse device for the current session.}
{MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouClose closes the mouse device for the current session and removes the
mouse device driver handle from the list of valid open mouse device
handles.}
function MouClose(MouHandle:word):word; cdecl;
{Notify the mouse device driver that the area defined by the passed parameters
if for exclusive use of the application. This area is defined as the
"collision" area and is not available to the mouse device driver when drawing
pointer images.}
{ProtectArea is the pointer shape collision area, MouHandle is the mouse device
handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouRemovePtr may be issued by any process in the session. However, only one
collision area is active at a time. Each MouRemovePtr command has the effect
of resetting the collision area to the location and area specified
by the current command.
* If the logical pointer position is outside of the collision area specified
by the latest MouRemovePtr command, the pointer image is drawn.
* The MouDrawPtr command effectively cancels the MouRemovePtr command
and allows the pointer to be drawn anywhere on the screen, until a new
MouRemovePtr command is issued.}
function MouRemovePtr(var ProtectArea:TNoPtrRect;MouHandle:word):word; cdecl;
{Notify the mouse device driver that an area previously restricted
to the pointer image is now available to the mouse device driver.}
{MouHandle is the mouse device handle from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* The collision area (the pointer image restricted area) is established by
MouOpen and by MouRemovePtr. MouDrawPtr nullifies the effect of the
MouRemovePtr command. If there was no previous MouDrawPtr command or if a
previous MouDrawPtr command has already nullified the collision area, the
MouRemovePtr command is effectively a null operation.
* This call is required to begin session pointer image drawing. Immediately
after MouOpen is issued, the collision area is defined as the size of the
display. A MouDrawPtr is issued to begin pointer drawing after the
MouOpen.}
function MouDrawPtr(MouHandle:word):word; cdecl;
{Set the mouse device driver status flags for the installed mouse device
driver.}
{Status contains the desired status flag settings (2-byte set, only the
high-order byte has meaning - see MOUSE_DISABLED and MOUSE_MICKEYS constants;
other bits are reserved and set to zero). MouHandle is the mouse device handle
from a previous MouOpen call.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
387 ERROR_MOUSE_INV_PARMS
466 ERROR_MOU_DETACHED
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouSetDevStatus is the complement to MouGetDevStatus. However, not all status
flags may be set with MouSetDevStatus. Only the flags corresponding
to the following functions may be modified:
- Return data in mickeys
Normally, mouse data is returned to the application with the absolute
display mode coordinates of the pointer image position on the display
screen. By setting this status flag, mouse data is returned in relative
mickeys, a unit of mouse movement.
- Don't call pointer draw device
Normally, the pointer draw device driver is called for all drawing
operations. By setting this status flag, the mouse device driver does not
call the pointer draw device driver. The application must draw any required
pointer image on the screen.}
function MouSetDevStatus(var Status:word;MouHandle:word):word; cdecl;
{Initialize mouse pointer draw support for DOS mode.}
{Name of the Pointer Draw Device Driver used as the pointer-image drawing
routine for the DOS mode session must sent in DriverName; the name of the
device driver must be included in the CONFIG.SYS file at system start-up time.}
{Possible return codes:
0 NO_ERROR
385 ERROR_MOUSE_NO_DEVICE
466 ERROR_MOU_DETACHED
412 ERROR_MOUSE_SMG_ONLY
501 ERROR_MOUSE_NO_CONSOLE
505 ERROR_MOU_EXTENDED_SG}
{Remarks:
* MouInitReal is issued by the Base Video Subsystem at system initialization
time.
* The DOS mode mouse API (INT 33h), in contrast to the OS/2 mode Mouse API,
does not contain an OPEN command. In addition, there is only one session
for DOS mode.
* The default pointer draw routine for DOS mode is located in the same pointer
draw device driver, POINTER$, that is used for OS/2 mode. Establishing
addressability to the pointer draw routine must be done during system
initialization. This requires passing the entry point of the DOS mode pointer
draw routine to the mouse device driver. This is the purpose
of the MouInitReal call. It passes the address of the default, power-up
pointer draw routine for DOS mode to the mouse device driver. This
initialization is transparent to applications.
* This call is for use only by the Base Video Subsystem when invoked during
system initialization under the shell/session manager PID.
* The error code ERROR_MOUSE_SMG_ONLY is valid from shell process only.
* When using direct calls to the 16-bit routine, another version of this call
is supported as well - if the selector part of the far pointer is zero
and the offset portion is non-zero, the offset portion identifies the
power-up display configuration. However, this isn't possible in the current
implementation (using 32-bit wrap-around function supplied in EMXWRAP.DLL).}
function MouInitReal(DriverName:PChar):word; cdecl;
function MouInitReal(DriverName:string):word;
{Synchronize the mouse subsystem with the mouse device driver.}
{WaitFlag specifies whether the routine should wait for the mouse device driver
being free - see MOU_NOWAIT and MOU_WAIT constants.}
{Possible return codes:
0 NO_ERROR
121 ERROR_SEM_TIMEOUT}
{Remarks:
* MouSynch blocks all other threads within a session until the semaphore
clears (returns from the subsystem to the router). To ensure proper
synchronization, MouSynch should be issued by a mouse subsystem if it intends
to access dynamically modifiable shared data for each session or if it
intends to issue a DosDevIOCtl. MouSynch does not protect globally shared
data from threads in other sessions.}
function MouSynch(WaitFlag:word):word; cdecl;
function MouGetThreshold(var MouThreshold:TThreshold;MouHandle:word):word;
cdecl;
function MouSetThreshold(var MouThreshold:TThreshold;MouHandle:word):word;
cdecl;
(*
following two functions are undocumented and not present within C header files:
function MouGetHotKey(var ButtonBits:word;MouHandle:word):word;
function MouSetHotKey(var ButtonBits:word;MouHandle:word):word;
*)
(* Following routines are not supported
(just have a look in some C header
file - you probably won't find it there either).
MouFree (index 4)
MouShellInit (index 12)
*)
{***************************************************************************}
implementation
{***************************************************************************}
function MouRegister(ModuleName,ProcName:PChar;FnMask:cardinal):word; cdecl;
external 'EMXWRAP' index 324;
{external 'MOUCALLS' index 24;}
function MouRegister(ModuleName,ProcName:string;FnMask:cardinal):word;
begin
if byte(ModuleName[0])>8 then byte(ModuleName[0]):=8;
ModuleName[Succ(byte(ModuleName[0]))]:=#0;
if byte(ProcName[0])>32 then byte(ProcName[0]):=32;
ProcName[Succ(byte(ProcName[0]))]:=#0;
MouRegister:=MouRegister(@ModuleName[1],@ProcName[1],FnMask);
end;
function MouDeRegister:word; cdecl;
external 'EMXWRAP' index 314;
{external 'MOUCALLS' index 14;}
function MouFlushQue(MouHandle:word):word; cdecl;
external 'EMXWRAP' index 307;
{external 'MOUCALLS' index 7;}
function MouGetPtrPos(var MouPtr:TPtrLoc;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 319;
{external 'MOUCALLS' index 19;}
function MouSetPtrPos(const MouPtr:TPtrLoc;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 321;
{external 'MOUCALLS' index 21;}
function MouSetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
external 'EMXWRAP' index 302;
{external 'MOUCALLS' index 2;}
function MouSetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
external 'EMXWRAP' index 302;
{external 'MOUCALLS' index 2;}
function MouGetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
external 'EMXWRAP' index 301;
{external 'MOUCALLS' index 1;}
function MouGetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word; cdecl;
external 'EMXWRAP' index 301;
{external 'MOUCALLS' index 1;}
function MouGetDevStatus(var Status:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 322;
{external 'MOUCALLS' index 22;}
function MouGetNumButtons(var ButtonCount:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 308;
{external 'MOUCALLS' index 8;}
function MouGetNumMickeys(var MickeyCnt:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 303;
{external 'MOUCALLS' index 3;}
function MouReadEventQue(var Event:TMouEventInfo;var WaitFlag:word;
MouHandle:word):word; cdecl;
external 'EMXWRAP' index 320;
{external 'MOUCALLS' index 20;}
function MouGetNumQueEl(var MouseQInfo:TMouQueInfo;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 313;
{external 'MOUCALLS' index 13;}
function MouGetEventMask(var EventMask:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 315;
{external 'MOUCALLS' index 15;}
function MouSetEventMask(var EventMask:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 316;
{external 'MOUCALLS' index 16;}
function MouGetScaleFact(var Scale:TScaleFact;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 306;
{external 'MOUCALLS' index 6;}
function MouSetScaleFact(const Scale:TScaleFact;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 311;
{external 'MOUCALLS' index 11;}
function MouOpen(DriverName:PChar;var MouHandle:word):word; cdecl;
external 'EMXWRAP' index 317;
{external 'MOUCALLS' index 17;}
function MouOpen(DriverName:string;var MouHandle:word):word;
var B:byte;
begin
B:=byte(DriverName[0]);
if B=0 then MouOpen:=MouOpen(nil,MouHandle) else
begin
if B<>255 then
begin
DriverName[Succ(B)]:=#0;
MouOpen:=MouOpen(@DriverName[1],MouHandle);
end else
begin
Move(DriverName[1],DriverName[0],B);
DriverName[B]:=#0;
MouOpen:=MouOpen(@DriverName,MouHandle);
end;
end;
end;
function MouClose(MouHandle:word):word; cdecl;
external 'EMXWRAP' index 309;
{external 'MOUCALLS' index 9;}
function MouRemovePtr(var ProtectArea:TNoPtrRect;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 318;
{external 'MOUCALLS' index 18;}
function MouDrawPtr(MouHandle:word):word; cdecl;
external 'EMXWRAP' index 326;
{external 'MOUCALLS' index 26;}
function MouSetDevStatus(var Status:word;MouHandle:word):word; cdecl;
external 'EMXWRAP' index 326;
{external 'MOUCALLS' index 26;}
function MouInitReal(DriverName:PChar):word; cdecl;
external 'EMXWRAP' index 327;
{external 'MOUCALLS' index 27;}
function MouInitReal(DriverName:string):word;
var B:byte;
begin
B:=byte(DriverName[0]);
if B=0 then MouInitReal:=MouInitReal(nil) else
begin
if B<>255 then
begin
DriverName[Succ(B)]:=#0;
MouInitReal:=MouInitReal(@DriverName[1]);
end else
begin
Move(DriverName[1],DriverName[0],B);
DriverName[B]:=#0;
MouInitReal:=MouInitReal(@DriverName);
end;
end;
end;
function MouSynch(WaitFlag:word):word; cdecl;
external 'EMXWRAP' index 323;
{external 'MOUCALLS' index 23;}
function MouGetThreshold(var MouThreshold:TThreshold;MouHandle:word):word;
cdecl;
external 'EMXWRAP' index 329;
{external 'MOUCALLS' index 29;}
function MouSetThreshold(var MouThreshold:TThreshold;MouHandle:word):word;
cdecl;
external 'EMXWRAP' index 330;
{external 'MOUCALLS' index 30;}
(*
following two functions are undocumented and not present within C header files:
function MouGetHotKey(var ButtonBits:word;MouHandle:word):word;
external 'MOUCALLS' index 4;
function MouSetHotKey(var ButtonBits:word;MouHandle:word):word;
external 'MOUCALLS' index 10;
*)
end.
Reference in New Issue View Git Blame Copy Permalink