paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-05 18:08:05 +02:00
Code Issues Packages Projects Releases Wiki Activity

* Updates

Browse Source
This commit is contained in:
daniel 1998-10-16 14:18:02 +00:00
parent 850e611770
commit 792c3bfd7e
5 changed files with 1154 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
rtl/os2/dos.pas
View File

@ -20,7 +20,7 @@ unit dos;
{$I os.inc}
{$I386_DIRECT}
{$ASMMODE ATT}
{***************************************************************************}
@ -72,35 +72,8 @@ type {Some string types:}
name:string; {Filenames can be long in OS/2!}
end;
{File record for untyped files:}
filerec = record
handle:word;
mode:word;
recsize:word;
_private:array[1..26] of byte;
userdata:array[1..16] of byte;
name:array[0..79] of char;
end;
{File record for text files:}
textbuf=array[0..127] of char;
textrec = record
handle:word;
mode:word;
bufSize:word;
_private:word;
bufpos:word;
bufend:word;
bufptr:^textbuf;
openfunc:pointer;
inoutfunc:pointer;
flushfunc:pointer;
closefunc:pointer;
userdata:array[1..16] of byte;
name:array[0..79] of char;
buffer:textbuf;
end;
{$i filerec.inc}
{$i textrec.inc}
{Data structure for the registers needed by msdos and intr:}
registers=record
@ -195,9 +168,9 @@ implementation
uses doscalls;
{Import ___SYSCALL to call it nicely from assembler procedures.
{Import syscall to call it nicely from assembler procedures.}
procedure syscall;external name '___SYSCALL';}
procedure syscall;external name '___SYSCALL';
function fsearch(path:pathstr;dirlist:string):pathstr;
@ -249,13 +222,13 @@ begin
movw (%ebx),%bx
{Get date}
movw $0x5700,%ax
call ___SYSCALL
call syscall
shll $16,%edx
movw %cx,%dx
movl time,%ebx
movl %edx,(%ebx)
xorb %ah,%ah
movw %ax,U_DOS_DOSERROR
movw %ax,doserror
end;
end;
@ -270,9 +243,9 @@ begin
shldl $16,%ecx,%edx
{Set date}
movw $0x5701,%ax
call ___SYSCALL
call syscall
xorb %ah,%ah
movw %ax,U_DOS_DOSERROR
movw %ax,doserror
end;
end;
@ -284,6 +257,8 @@ begin
intr($21,regs);
end;
{$ASMMODE DIRECT}
procedure intr(intno:byte;var regs:registers);
{Not recommended for EMX. Only works in DOS mode, not in OS/2 mode.}
@ -343,6 +318,8 @@ begin
end;
end;
{$ASMMODE ATT}
procedure exec(const path:pathstr;const comline:comstr);
{Execute a program.}
@ -424,6 +401,8 @@ begin
Oh boy, I always had the opinion that executing a program under Dos
was a hard job!}
{$ASMMODE DIRECT}
asm
movl env,%edi {Setup destination pointer.}
movl _envc,%ecx {Load number of arguments in edx.}
@ -445,6 +424,8 @@ begin
movl %edx,(24)es {Store environment size.}
end;
{$ASMMODE ATT}
{Environtment ready, now set-up exec structure.}
es.argofs:=args;
es.envofs:=env;
@ -457,9 +438,9 @@ begin
end;
es.nameofs:=pointer(longint(@path)+1);
asm
movw %ss,(12)es {Compiler doesn't like record elems in asm.}
movw %ss,(14)es
movw %ss,(16)es
movw %ss,es.argseg
movw %ss,es.envseg
movw %ss,es.nameseg
end;
es.sizearg:=j;
es.numenv:=0;
@ -471,14 +452,14 @@ begin
asm
leal es,%edx
mov $0x7f06,%ax
call ___SYSCALL
call syscall
xorl %edi,%edi
jnc exprg1
jnc .Lexprg1
xchgl %eax,%edi
xorl %eax,%eax
decl %eax
exprg1:
movl %edi,U_DOS_DOSERROR
.Lexprg1:
movw %di,doserror
movl %eax,__RESULT
end;
@ -493,7 +474,7 @@ function dosversion:word;assembler;
{Returns DOS version in DOS and OS/2 version in OS/2}
asm
movb $0x30,%ah
call ___SYSCALL
call syscall
end;
procedure getdate(var year,month,day,dayofweek:word);
@ -501,7 +482,7 @@ procedure getdate(var year,month,day,dayofweek:word);
begin
asm
movb $0x2a,%ah
call ___SYSCALL
call syscall
xorb %ah,%ah
movl 20(%ebp),%edi
stosw
@ -526,9 +507,9 @@ begin
movb 10(%ebp),%dh
movb 12(%ebp),%dl
movb $0x2b,%ah
call ___SYSCALL
call syscall
xorb %ah,%ah
movw %ax,U_DOS_DOSERROR
movw %ax,doserror
end;
end;
@ -537,7 +518,7 @@ procedure gettime(var hour,minute,second,sec100:word);
begin
asm
movb $0x2c,%ah
call ___SYSCALL
call syscall
xorb %ah,%ah
movl 20(%ebp),%edi
movb %dl,%al
@ -563,9 +544,9 @@ begin
movb 12(%ebp),%dh
movb 14(%ebp),%dl
movb $0x2d,%ah
call ___SYSCALL
call syscall
xorb %ah,%ah
movw %ax,U_DOS_DOSERROR
movw %ax,doserror
end;
end;
@ -576,7 +557,7 @@ begin
signal handling instead.}
asm
movw $0x3300,%ax
call ___SYSCALL
call syscall
movl 8(%ebp),%eax
movb %dl,(%eax)
end;
@ -589,8 +570,8 @@ begin
signal handling instead.}
asm
movb 8(%ebp),%dl
movl $0x3301,%ax
call ___SYSCALL
movw $0x3301,%ax
call syscall
end;
end;
@ -600,7 +581,7 @@ begin
{! Do not use in OS/2.}
asm
movb $0x54,%ah
call ___SYSCALL
call syscall
movl 8(%ebp),%edi
stosb
end;
@ -613,7 +594,7 @@ begin
asm
movb 8(%ebp),%al
movb $0x2e,%ah
call ___SYSCALL
call syscall
end;
end;
@ -627,9 +608,9 @@ begin
asm
movb 8(%ebp),%dl
movb $0x36,%ah
call ___SYSCALL
call syscall
cmpw $-1,%ax
je LDISKFREE1
je .LDISKFREE1
mulw %cx
mulw %bx
shll $16,%edx
@ -637,7 +618,7 @@ begin
xchgl %edx,%eax
leave
ret
LDISKFREE1:
.LDISKFREE1:
cwde
leave
ret
@ -664,10 +645,10 @@ begin
asm
movb 8(%ebp),%dl
movb $0x36,%ah
call ___SYSCALL
call syscall
movw %dx,%bx
cmpw $-1,%ax
je LDISKSIZE1
je .LDISKSIZE1
mulw %cx
mulw %bx
shll $16,%edx
@ -675,7 +656,7 @@ begin
xchgl %edx,%eax
leave
ret
LDISKSIZE1:
.LDISKSIZE1:
cwde
leave
ret
@ -734,10 +715,10 @@ procedure findfirst(const path:pathstr;attr:word;var f:searchRec);
{No need to set DTA in EMX. Just give a pointer in ESI.}
movl 18(%ebp),%esi
movb $0x4e,%ah
call ___SYSCALL
jnc LFF
movw %ax,U_DOS_DOSERROR
LFF:
call syscall
jnc .LFF
movw %ax,doserror
.LFF:
end;
end;
@ -759,10 +740,10 @@ procedure findnext(var f:searchRec);
asm
movl 12(%ebp),%esi
movb $0x4f,%ah
call ___SYSCALL
jnc LFN
movw %ax,U_DOS_DOSERROR
LFN:
call syscall
jnc .LFN
movw %ax,doserror
.LFN:
end;
end;
@ -783,6 +764,8 @@ end;
type PPchar=^Pchar;
{$ASMMODE DIRECT}
function envs:PPchar;assembler;
asm
@ -797,6 +780,8 @@ asm
movl _envc,%eax
end ['EAX'];
{$ASMMODE ATT}
function envstr(index : longint) : string;
var hp:PPchar;
@ -863,8 +848,8 @@ begin
for i:=length(path) downto 1 do
if path[i]='.' then
begin
ext:=copy(path,p1,high(extstr));
delete(path,p1,length(path)-p1+1);
ext:=copy(path,i,high(extstr));
delete(path,i,length(path)-i+1);
break;
end;
name:=path;
@ -876,7 +861,7 @@ function fexpand(const path:pathstr):pathstr;
asm
movb $0x19,%ah
call ___SYSCALL
call syscall
end;
var s,pa:string;
@ -969,41 +954,36 @@ begin
d.year:=time+1980;
end;
procedure getfattr(var f;var attr : word);
procedure getfattr(var f;var attr : word);assembler;
var n:array[0..255] of char;
begin
strpcopy(n,filerec(f).name);
{Alas, msdos(r) doesn't work when we are running in OS/2.}
asm
movw $0x4300,%ax
leal n,%edx
call ___SYSCALL
movl attr,%ebx
movw %cx,(%ebx)
end;
asm
movw $0x4300,%ax
movl f,%edx
{addl $filerec.name,%edx Doesn't work!!}
addl $60,%edx
call syscall
movl attr,%ebx
movw %cx,(%ebx)
end;
procedure setfattr(var f;attr : word);
procedure setfattr(var f;attr : word);assembler;
var n:array[0..255] of char;
begin
strpcopy(n,filerec(f).name);
{Alas, msdos(r) doesn't work when we are running in OS/2.}
asm
movw $0x4301,%ax
leal n,%edx
movw attr,%cx
call ___SYSCALL
end;
asm
movw $0x4301,%ax
movl f,%edx
{addl $filerec.name,%edx Doesn't work!!}
addl $60,%edx
movw attr,%cx
call syscall
end;
end.
{
$Log$
Revision 1.7 1998-07-08 14:44:11 daniel
Revision 1.8 1998-10-16 14:18:02 daniel
* Updates
Revision 1.7 1998/07/08 14:44:11 daniel
+ Added moucalls and viocalls written by Tomas Hajny.
+ Final routines in doscalls implemented.
* Fixed bugs in dos.pas.

75
rtl/os2/kbdcalls.pas
View File

@ -36,6 +36,9 @@ unit KbdCalls;
{ Interface library to KBDCALLS.DLL (through EMXWRAP.DLL)
Variant records and aliases for some record types created to maintain highest
possible level of compatibility with other existing OS/2 compilers.
Changelog:
People:
@ -71,7 +74,8 @@ uses strings;
{$endif FPK}
const
{return codes / error constants (those marked with * shouldn't occur)}
{return codes / error constants (those marked with * shouldn't occur under
normal conditions)}
NO_ERROR = 0;
ERROR_SEM_TIMEOUT =121;
ERROR_KBD_PARAMETER =373;
@ -171,6 +175,16 @@ const
KBDTRF_FINAL_CHAR_IN =$40; {either $40 or $80 or both}
KBDTRF_INTERIM_CHAR_IN =$80; {must be present }
{TKbdHWID.idKbd}
Keyboard_Undetermined =$0000; {undetermined keyboard type}
Keyboard_AT_Compatible =$0001; {PC-AT Standard Keyboard}
Keyboard_Enhanced_101 =$AB41; {101 Key Enhanced Keyboard}
Keyboard_Enhanced_102 =$AB41; {102 Key Enhanced Keyboard}
Keyboard_Enhanced_88_89 =$AB54; {88 and 89 Key Enhanced Keyboards}
Keyboard_Enhanced_122 =$AB85; {122 Key Enhanced Keyboard}
Keyboard_AT_Compatable=Keyboard_AT_Compatible;
Keyboard_SpaceSaver=Keyboard_Enhanced_88_89;
type
@ -183,22 +197,30 @@ type
chChar:char; {ASCII character code; the scan code received}
{from the keyboard is translated to the ASCII}
{character code }
case boolean of
false:(
chScan:byte; {scan Code received from the keyboard}
fbStatus:byte; {state of the keystroke event, see KBDTRF_*}
bNlsShift:byte; {NLS shift status (always 0?)}
fsState:word; {shift key status, see KBDSTF_*}
Time:cardinal; {time stamp indicating when a key was pressed,}
Time:cardinal); {time stamp indicating when a key was pressed,}
{specified in milliseconds from the time }
{the system was started }
true:(
chScan2:char; (* should be chScan and bNlsShift, but this *)
fbStatus2:byte; (* construct is unsupported currently *)
bNlsShift2:char);
end;
PKbdKeyInfo=^TKbdKeyInfo;
KbdKeyInfo=TKbdKeyInfo; {for better compatibility with other compilers}
{record type for KbdStringIn}
TStringInBuf=record
cb:word; {length of the input buffer, maximum length is 255}
cchIn:word; {number of bytes actually read into the buffer}
end;
PStringInBuf=TStringInBuf;
PStringInBuf=^TStringInBuf;
StringInBuf=TStringInBuf;
{TKbdInfo record type, for KbdSet/GetStatus}
TKbdInfo=record
@ -209,7 +231,7 @@ type
{and extended-ASCII format, the turn-around character}
{is defined as the carriage return, in ASCII format }
{only, the turn-around character is defined in the }
{low-order byte; usually $000D }
{low-order byte; usually $000D }
fsInterim, {interim character flags: bits 0-4 and 6 - reserved }
{ and set to 0,}
{ bit 5 - application}
@ -224,6 +246,7 @@ type
fsState:word; {shift state, see TKbdInfo.fsState constants}
end;
PKbdInfo=^TKbdInfo;
KbdInfo=TKbdInfo;
{record type for KbdGetHWID}
TKbdHWID=record
@ -237,10 +260,12 @@ type
{ $AB54 = 88 and 89 Key Enhanced }
{ Keyboards }
{ $AB85 = 122 Key Enhanced Keyboard }
{- see KEYBOARD_* constants }
usReserved1, {reserved, returned set to zero (secondary ID?)}
usReserved2:word; {reserved, returned set to zero}
end;
PKbdHWID=^TKbdHWID;
KbdHWID=TKbdHWID;
{record type for KbdXlate}
(* #pragma pack(2) ???*)
@ -252,15 +277,17 @@ type
chChar:char; {ASCII character code; the scan code received}
{from the keyboard is translated to the ASCII}
{character code }
chScan:byte; {scan Code received from the keyboard}
fbStatus:byte; {state of the keystroke event, see KBDTRF_*}
case boolean of
false:(
chScan, {scan Code received from the keyboard}
fbStatus, {state of the keystroke event, see KBDTRF_*}
bNlsShift:byte; {NLS shift status (always 0?)}
fsState:word; {shift key status, see KBDSTF_*}
Time:cardinal; {time stamp indicating when a key was pressed,}
{specified in milliseconds from the time }
{the system was started }
fsDD:word; {device driver returned flag,}
{see KbdDDFlagWord notes }
fsDD:word; {device driver returned flag, }
{see KbdDDFlagWord notes below}
fsXlate:word; {translation flag: 0 - translation incomplete,}
{ 1 - translation complete }
fsShift:word; {identifies the state of translation across }
@ -270,8 +297,13 @@ type
{should not be changed unless a new translation}
{is required (that is, reset value to zero) }
sZero:word); {reserved, set to 0}
true:(
chScan2, (* should be chScan, fbStatus and bNlsShift, *)
fbStatus2, (* but this construct is unsupported currently *)
bNlsShift2:char));
end;
PKbdTrans=^TKbdTrans;
KbdTrans=TKbdTrans;
{KbdDDFlagWord notes:
bits 15-14 Available. These bits are available for communication between
@ -1317,6 +1349,8 @@ default keyboard (0) or a logical keyboard.}
(focus), or is equal to zero and no other handle has the focus.}
function KbdStringIn(var CharBuf;var LenInOut:TStringInBuf;WaitFlag:word;
KbdHandle:word):word;
function KbdStringIn(CharBuf:PChar;LenInOutP:PStringInBuf;WaitFlag:word;
KbdHandle:word):word;
{Clear the keystroke buffer.}
{KbdHandle is the default keyboard (0) or a logical keyboard.}
@ -1520,6 +1554,7 @@ function KbdGetHWID(var HWID:TKbdHWID;KbdHandle:word):word;
{Undocumented in official IBM documentation}
function KbdSetHWID(var HWID:TKbdHWID;KbdHandle:word):word;
function KbdSetHWID(HWIDP:PKbdHWID;KbdHandle:word):word;
{Translate scan codes with shift states into ASCII codes.}
{TransData - see TKbdTransData, KbdHandle is the default keyboard (0) or a
@ -1545,8 +1580,9 @@ function KbdXlate(var TransData:TKbdTrans;KbdHandle:word):word;
{Install, on the specified handle, the translate table which this call points
to. This translate table affects only this handle.}
{XLateTbl is the translation table used to translate scan code to ASCII code
for a specified handle, KbdHandle is the default keyboard (0) or a logical
keyboard.}
for a specified handle (the format of the translation table is documented in
the Set Code Page IOCTL 50h), KbdHandle is the default keyboard (0) or a
logical keyboard.}
{Possible return codes:
0 NO_ERROR
377 ERROR_KBD_INVALID_ECHO_MASK
@ -1564,6 +1600,8 @@ keyboard.}
the caller for the translate table and is freed before the KbdSetCp is
performed, KbdSetCp and future translations may fail.}
function KbdSetCustXt(var XLateTbl:TXLateTbl;KbdHandle:word):word;
function KbdSetCustXt(var CodePage:word;KbdHandle:word):word;
function KbdSetCustXt(var XLateTblP:pointer;KbdHandle:word):word;
(* Following routines are not supported
@ -1612,6 +1650,11 @@ function KbdStringIn(var CharBuf;var LenInOut:TStringInBuf;WaitFlag:word;
external 'EMXWRAP' index 209;
{external 'KBDCALLS' index 9;}
function KbdStringIn(CharBuf:PChar;LenInOutP:PStringInBuf;WaitFlag:word;
KbdHandle:word):word;
external 'EMXWRAP' index 209;
{external 'KBDCALLS' index 9;}
function KbdFlushBuffer(KbdHandle:word):word;
external 'EMXWRAP' index 213;
{external 'KBDCALLS' index 13;}
@ -1664,6 +1707,10 @@ function KbdSetHWID(var HWID:TKbdHWID;KbdHandle:word):word;
external 'EMXWRAP' index 225;
{external 'KBDCALLS' index 25;}
function KbdSetHWID(HWIDP:PKbdHWID;KbdHandle:word):word;
external 'EMXWRAP' index 225;
{external 'KBDCALLS' index 25;}
function KbdXlate(var TransData:TKbdTrans;KbdHandle:word):word;
external 'EMXWRAP' index 214;
{external 'KBDCALLS' index 14;}
@ -1672,6 +1719,14 @@ function KbdSetCustXt(var XLateTbl:TXLateTbl;KbdHandle:word):word;
external 'EMXWRAP' index 201;
{external 'KBDCALLS' index 1;}
function KbdSetCustXt(var CodePage:word;KbdHandle:word):word;
external 'EMXWRAP' index 201;
{external 'KBDCALLS' index 1;}
function KbdSetCustXt(var XLateTblP:pointer;KbdHandle:word):word;
external 'EMXWRAP' index 201;
{external 'KBDCALLS' index 1;}
end.

271
rtl/os2/moncalls.pas Normal file
View File

@ -0,0 +1,271 @@
{Set tabsize to 4.}
{****************************************************************************
MONCALLS interface unit
FPK-Pascal Runtime Library for OS/2
Copyright (c) 1993,94 by Florian Kl„mpfl
Copyright (c) 1997 by Dani‰l Mantione
Copyright (c) 1998 by Tomas Hajny
The FPK-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 FPK 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 FPK Pascal source code file.>
Send us your modified files, we can work together if you want!
FPK-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 FPK-Pascal; see the file COPYING.LIB. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
****************************************************************************}
unit MonCalls;
{ Interface library to MONCALLS.DLL (through EMXWRAP.DLL)
Please, note, that monitors are supported for OS/2 v2.1 and above only
(not for v2.0) and that they cannot be used in PM applications.
Changelog:
People:
TH - Tomas Hajny
Date: Description of change: Changed by:
- First released version 1.0 TH
Coding style:
I have tried to use the same coding style as Dani‰l 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 Dani‰l 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
{***************************************************************************}
uses strings;
{$ifdef FPK}
{$packrecords 1}
{$endif FPK}
const
{return codes / error constants (those marked with * shouldn't occur)}
NO_ERROR = 0;
ERROR_NOT_ENOUGH_MEMORY = 8;
ERROR_OPEN_FAILED = 110;
ERROR_MONITORS_NOT_SUPPORTED = 165;
ERROR_MON_INVALID_PARMS = 379;
ERROR_MON_INVALID_DEVNAME = 380;
ERROR_MON_INVALID_HANDLE = 381;
ERROR_MON_BUFFER_TOO_SMALL = 382;
ERROR_MON_BUFFER_EMPTY = 383;
ERROR_MON_DATA_TOO_LARGE = 384;
ERROR_MON_BAD_BUFFER = 730; {*}
ERROR_MON_CHAIN_HANDLE = 32784; {*}
ERROR_MON_NOT_REGISTERED = 32785; {*}
{WaitFlag}
IO_WAIT =0; {The monitor thread that issues DosMonRead wishes to block}
{until a data record is available in its input buffer.}
IO_NOWAIT =1; {The monitor thread that issues DosMonRead does not wish}
{to block when its input buffer is empty.}
{Terminate character device monitoring. All monitor buffers associated with
this process are flushed and closed.}
{MonHandle - device handle returned from a previous DosMonOpen call.}
{Possible return codes:
0 NO_ERROR
381 ERROR_MON_INVALID_HANDLE}
{Remarks:
* A single process may register one or more monitors with a character device
using the same device handle returned from a previous DosMonOpen call.
When DosMonClose is issued for a specific, opened device handle, all
monitors for the current process registered with this handle terminate.
* When DosMonClose is issued, the monitor loses access to the device data
stream. Before issuing DosMonClose, monitor threads calling DosMonRead and
DosMonWrite should be terminated. After DosMonClose has been called,
DosMonRead calls return an ERROR_MON_BUFFER_EMPTY return code and
DosMonWrite calls return an ERROR_NOT_ENOUGH_MEMORY return code.
* Data area containing monitor buffers should not be freed until after
DosMonClose is called. If data area containing monitor buffers is freed
before DosMonClose is called, a GP fault occurs when DosMonClose is called
and the process is terminated.
* For a detailed description of this call see the chapter "Character Device
Monitors" in the IBM Operating System/2 Version 1.2 I/O Subsystems And
Device Support Volume 1.}
function DosMonClose(MonHandle:word):word;
{Gain access to a character device data stream.}
{DevName - device name, monitor handle returned in MonHandle.}
{Possible return codes:
0 NO_ERROR
110 ERROR_OPEN_FAILED
379 ERROR_MON_INVALID_PARMS
380 ERROR_MON_INVALID_DEVNAME}
{Remarks:
* Only one DosMonOpen call is necessary per device per process. That is,
several DosMonReg calls can be made using the same monitor handle to the
same device. This allows monitors to be registered using different values
for Index from the same process and going to the same device. When the
DosMonClose is issued, all of the monitors registered on the handle are
closed.
* For a detailed description of this call see the chapter "Character Device
Monitors" in the IBM Operating System/2 Version 1.2 I/O Subsystems And
Device Support Volume 1.}
function DosMonOpen(DevName:PChar;var MonHandle:word):word;
function DosMonOpen(DevName:string;var MonHandle:word):word;
{Wait for a data record, move it from the input buffer of a registered
character device monitor and place it in a private data area where the monitor
can freely access it.}
{InBuf - monitor input buffer, WaitFlag - see IO_WAIT and IO_NOWAIT constants,
DataBuf - data area in the calling process address space that the data from the
monitor's input buffer is read into, ByteCount - on input size of the DataBuf,
on return number of bytes of data moved.}
{Possible return codes:
0 NO_ERROR
379 ERROR_MON_INVALID_PARMS
382 ERROR_MON_BUFFER_TOO_SMALL
383 ERROR_MON_BUFFER_EMPTY}
{Remarks:
* For a detailed description of this call see the chapter "Character Device
Monitors" in the IBM Operating System/2 Version 1.2 I/O Subsystems And
Device Support Volume 1.}
function DosMonRead(var InBuf;WaitFlag:byte;var DataBuf;
var ByteCount:word):word;
{Establish an input and output buffers to monitor an I/O stream for a character
device.}
{MonHandle - device handle returned from a previous DosMonOpen call, InBuf -
monitor input buffer, the monitor dispatcher moves data records into this
buffer from the device driver (if the monitor is the first one in the monitor
chain) or from the previous monitor in the chain, monitor then takes data from
this buffer for filtering by calling DosMonRead, OutBuf - monitor output
buffer, monitor places filtered data into this buffer by calling DosMonWrite,
the monitor dispatcher moves data records from this buffer to the device driver
(if the monitor is the last one in the monitor chain) or to the next monitor in
the chain, PosCode - used to specify placement of a monitor's buffers with the
monitor chain (FIRST, LAST or DEFAULT) and whether one or two threads are
created by the monitor dispatcher to handle data movement (see explanation
bellow), Index - device specific value, for the keyboard it pertains to the
session you wish to register a monitor on, for the printer it pertains to the
data or code page monitor chain.}
{Possible return codes:
0 NO_ERROR
8 ERROR_NOT_ENOUGH_MEMORY
165 ERROR_MONITORS_NOT_SUPPORTED
379 ERROR_MON_INVALID_PARMS
381 ERROR_MON_INVALID_HANDLE
382 ERROR_MON_BUFFER_TOO_SMALL}
{Remarks:
* PosCode meaning:
0 DEFAULT (no position preference) and one thread for data movement
1 FIRST (monitor placed at beginning of monitor chain) and one thread for
data movement
2 LAST (monitor placed at the end of monitor chain) and one thread for
data movement
3 DEFAULT with two threads for data movement
4 FIRST with two threads for data movement
5 LAST with two threads for data movement
The first monitor in a monitor chain that registers as FIRST is placed at the
head of the monitor chain. The next monitor that registers as FIRST follows
the last monitor registered as FIRST, and so on. Similarly, the first monitor
that registers as LAST is placed at the end of the monitor chain. The next
monitor that registers as LAST is placed before the last monitor that
registered as LAST, and so on. The first monitor that registers as DEFAULT is
placed before the last monitor, if any, that registered as LAST. The next
monitor that registers as DEFAULT is placed before the last monitor that
registered as DEFAULT, and so on.
* For a detailed description of this call see the chapter "Character Device
Monitors" in the IBM Operating System/2 Version 1.2 I/O Subsystems And
Device Support Volume 1.}
function DosMonReg(MonHandle:word;var InBuf,OutBuf;PosCode,Index:word):word;
{Move a filtered data record from the monitor's private data area into the
monitor's output buffer.}
{OutBuf - monitor output buffer, DataBuf - monitor's private data area
containing a filtered data record of length ByteCount, this filtered data
record is moved into the monitor's output buffer by this call, ByteCount - size
of the data record.}
{Possible return codes:
0 NO_ERROR
8 ERROR_NOT_ENOUGH_MEMORY
379 ERROR_MON_INVALID_PARMS
384 ERROR_MON_DATA_TOO_LARGE}
{Remarks:
* For a detailed description of the use of this call see the chapter
"Character Device Monitors" in the IBM Operating System/2 Version 1.2 I/O
Subsystems And Device Support Volume 1.}
function DosMonWrite(var OutBuf,DataBuf;ByteCount:word):word;
{***************************************************************************}
implementation
{***************************************************************************}
function DosMonClose(MonHandle:word):word;
external 'EMXWRAP' index 403;
{external 'MONCALLS' index 3;}
function DosMonOpen(DevName:PChar;var MonHandle:word):word;
external 'EMXWRAP' index 404;
{external 'MONCALLS' index 4;}
function DosMonOpen(DevName:string;var MonHandle:word):word;
begin
if DevName[0]=#255 then
begin
I:=byte(DevName[0]);
Move(DevName[1],DevName[0],255);
DevName[255]:=#0;
DosMonOpen:=DosMonOpen(@DevName,MonHandle);
end else
begin
DevName[Succ(byte(DevName[0]))]:=#0;
DosMonOpen:=DosMonOpen(@DevName[1],MonHandle);
end;
end;
function DosMonRead(var InBuf;WaitFlag:word;var DataBuf;
var ByteCount:word):word;
external 'EMXWRAP' index 402;
{external 'MONCALLS' index 2;}
function DosMonReg(MonHandle:word;var InBuf,OutBuf;PosCode,Index:word):word;
external 'EMXWRAP' index 405;
{external 'MONCALLS' index 5;}
function DosMonWrite(var OutBuf,DataBuf;ByteCount:word):word;
external 'EMXWRAP' index 401;
{external 'MONCALLS' index 1;}
end.


742
rtl/os2/moucalls.pas
View File

@ -36,15 +36,18 @@ unit MouCalls;
{ Interface library to MOUCALLS.DLL (through EMXWRAP.DLL)
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
TH - Tomas Hajny (xhajt03@mbox.vol.cz on Internet)
Date: Description of change: Changed by:
- First released version 0.50 TH
- First released version 1.0 TH
Coding style:
@ -71,30 +74,33 @@ uses strings;
{$endif FPK}
const
{return codes / error constants}
{return codes / error constants (those marked with * shouldn't occur under
normal conditions)}
NO_ERROR = 0;
ERROR_SEM_TIMEOUT =121;
ERROR_MOUSE_NO_DEVICE =385;
ERROR_MOUSE_INV_HANDLE =386;
ERROR_MOUSE_INV_HANDLE =386; {*}
ERROR_MOUSE_INV_PARMS =387;
ERROR_MOUSE_CANT_RESET =388;
ERROR_MOUSE_DISPLAY_PARMS =389;
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;
ERROR_MOUSE_INV_ENTRY_PT =391; {*}
ERROR_MOUSE_INV_MASK =392; {*}
NO_ERROR_MOUSE_NO_DATA =393;
NO_ERROR_MOUSE_PTR_DRAWN =394;
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_MOUSE_INVALID_IOWAIT =435; {*}
ERROR_MOU_DETACHED =466;
ERROR_MOUSE_NO_CONSOLE =501;
ERROR_MOUSE_INVALID_HANDLE =502;
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;
ERROR_MOU_NOT_INITIALIZED =530; {*}
ERROR_MOUINITREAL_DONE =531; {*}
ERROR_MOUSE_CALLER_NOT_SUBSYS =533; {*}
{constants for FnMask in MouRegister}
MR_MOUGETNUMBUTTONS =$00000001;
@ -123,25 +129,39 @@ const
MHK_BUTTON3 =4;
{MouGetDevStatus/MouSetDevStatus device status constants}
MOUSE_QUEUEBUSY =$0001;
MOUSE_BLOCKREAD =$0002;
MOUSE_FLUSH =$0004;
MOUSE_UNSUPPORTED_MODE =$0008;
MOUSE_DISABLED =$0100;
MOUSE_MICKEYS =$0200;
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}
MOU_NOWAIT =$0000;
MOU_WAIT =$0001;
{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;
MOUSE_MOTION_WITH_BN1_DOWN =$0002;
MOUSE_BN1_DOWN =$0004;
MOUSE_MOTION_WITH_BN2_DOWN =$0008;
MOUSE_BN2_DOWN =$0010;
MOUSE_MOTION_WITH_BN3_DOWN =$0020;
MOUSE_BN3_DOWN =$0040;
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;
@ -159,119 +179,708 @@ type
THMOU=word;
PHMOU=^THMOU;
{record type for MouGetPos/SetPtrPos}
{record type for MouGetPtrPos/MouSetPtrPos}
TPtrLoc=record
Row:word;
Col:word;
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 MouGetShape/SetPtrShape}
{record type for MouGetPtrShape/MouSetPtrShape}
TPtrShape=record
cb:word; {length of image buffer in bytes}
Col:word; {pointer width in characters or pixels}
Row:word; {pointer height in characters or pixels}
ColHot:word; {hotspot offset from the left side}
RowHot:word; {hotspot offset from the top}
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}
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}
Row:integer; {pointer current row position}
{(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:word; {number of elements in event queue}
cmaxEvents:word; {maximum queue size in elements}
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:word; {scaling factor of current row}
ColScale:word; {scaling factor of current column}
RowScale, {current row scaling factor}
ColScale:word; {current column scaling factor}
end;
PScaleFact=^TScaleFact;
ScaleFact=TScaleFact;
{record type for MouRemovePtr}
TNoPtrRect=record
Row:word; {row of the top of the rectangle}
Col:word; {column of the left edge}
cRow:word; {row of the bottom}
cCol:word; {column of the right edge}
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
Length:word;
Level1:word; {first movement level}
Lev1Mult:word; {first level multiplier}
Level2:word; {second movement level}
Lev2Mult:word; {second level multiplier}
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;
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;
{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;
{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;
function MouSetPtrPos(var MouPtr:TPtrLoc;MouHandle:word):word;
{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;
{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;
function MouSetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word;
{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;
function MouGetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word;
{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;
{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;
{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;
{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;
{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;
{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;
{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;
{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;
function MouSetScaleFact(var Scale:TScaleFact;MouHandle:word):word;
{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;
{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;
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;
{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;
{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;
{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;
{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;
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;
function MouGetThreshold(var MouThreshold:TThreshold;MouHandle:word):word;
@ -323,7 +932,7 @@ function MouGetPtrPos(var MouPtr:TPtrLoc;MouHandle:word):word;
external 'EMXWRAP' index 319;
{external 'MOUCALLS' index 19;}
function MouSetPtrPos(var MouPtr:TPtrLoc;MouHandle:word):word;
function MouSetPtrPos(const MouPtr:TPtrLoc;MouHandle:word):word;
external 'EMXWRAP' index 321;
{external 'MOUCALLS' index 21;}
@ -332,6 +941,16 @@ function MouSetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
external 'EMXWRAP' index 302;
{external 'MOUCALLS' index 2;}
function MouSetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word;
external 'EMXWRAP' index 302;
{external 'MOUCALLS' index 2;}
function MouGetPtrShape(var ImageBuf;var ImageInfo:TPtrShape;
MouHandle:word):word;
external 'EMXWRAP' index 301;
{external 'MOUCALLS' index 1;}
function MouGetPtrShape(ImageBuf:pointer;var ImageInfo:TPtrShape;
MouHandle:word):word;
external 'EMXWRAP' index 301;
@ -370,7 +989,7 @@ function MouGetScaleFact(var Scale:TScaleFact;MouHandle:word):word;
external 'EMXWRAP' index 306;
{external 'MOUCALLS' index 6;}
function MouSetScaleFact(var Scale:TScaleFact;MouHandle:word):word;
function MouSetScaleFact(const Scale:TScaleFact;MouHandle:word):word;
external 'EMXWRAP' index 311;
{external 'MOUCALLS' index 11;}
@ -465,3 +1084,4 @@ external 'MOUCALLS' index 10;
end.


78
rtl/os2/viocalls.pas
View File

@ -36,11 +36,14 @@ unit VioCalls;
{ Interface library to VIOCALLS.DLL (through EMXWRAP.DLL)
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
TH - Tomas Hajny (xhajt03@mbox.vol.cz on Internet)
Date: Description of change: Changed by:
@ -74,6 +77,7 @@ uses strings;
const
{return codes / error constants}
NO_ERROR = 0;
ERROR_VIO_INVALID_MASK =349;
ERROR_VIO_PTR =350;
ERROR_VIO_APTR =351;
@ -364,39 +368,55 @@ type
Attr:word; {Cursor colour attribute (-1=hidden)}
end;
PVioCursorInfo=^TVioCursorInfo;
VioCursorInfo=TVioCursorInfo;
{record type for VioSetMode/GetMode}
TVioModeInfo=record
cb:word; {Size of the record}
fbType:byte; {8-bit mask identifying the mode}
case boolean of
false:(
fbType, {8-bit mask identifying the mode}
{- see VGMT_* constants }
Color:byte; {Number of colour bits available}
{(1=>2 colours, 2=>4,...) - see }
{COLORS_* constants }
Col:word; {Number of text character columns}
Row:word; {Number of text character rows}
HRes:word; {Display width in pixels}
Col, {Number of text character columns}
Row, {Number of text character rows}
HRes, {Display width in pixels}
VRes:word; {Display height in pixels}
fmt_ID:byte; {Format of the attributes}
fmt_ID, {Format of the attributes}
Attrib:byte; {Number of attributes in fmt_ID field}
Buf_Addr:cardinal; {Address of the physical display buffer}
Buf_Length:cardinal; {Length of the physical display buffer}
Full_Length:cardinal; {Size of the buffer needed to save}
Buf_Addr, {Address of the physical display buffer}
Buf_Length, {Length of the physical display buffer}
Full_Length, {Size of the buffer needed to save}
{the whole physical buffer }
Partial_Length:cardinal; {Size of the buffer needed to save}
{the part of the physical buffer }
{overwritten with VioPopup }
Ext_Data_Addr:pointer; {Address of an extended-mode data}
Ext_Data_Addr:pointer); {Address of an extended-mode data}
true:(
fbType2, (* should be fbType, Color, etc., but this *)
Color2:char; (* construct is unsupported currently *)
Col2,
Row2,
HRes2,
VRes2:word;
fmt_ID2,
Attrib2:char);
end;
PVioModeInfo=^TVioModeInfo;
VioModeInfo=TVioModeInfo;
{record type for VioGetPhysBuf}
TVioPhysBuf=record
pBuf:pointer; {Absolute screen address}
cb:cardinal; {Length of the buffer in bytes}
Sel:word; {Selector for video access}
pBuf:pointer; {Absolute screen address}
cb:cardinal; {Length of the buffer in bytes}
case boolean of
false:(Sel:word); {Selector for video access}
true:(aSel:array[0..0] of word);
end;
PVioPhysBuf=^TVioPhysBuf;
VioPhysBuf=TVioPhysBuf;
{record type for VioGetConfig}
(* #pragma pack(2) ??? *)
@ -425,17 +445,27 @@ type
{about emulated display types}
end;
PVioConfigInfo=^TVioConfigInfo;
VioConfigInfo=TVioConfigInfo;
{record type for VioGetFont/VioSetFont}
TVioFontInfo=record
cb:word; {Size of the record}
rType:word; {Request type}
cxCell:word; {Columns per cell (cell width)}
cyCell:word; {Rows per cell (cell height)}
pbData:pointer; {Address of caller's buffer}
cbData:word; {Size of caller's buffer in bytes}
cb:word; {Size of the data record}
case byte of
1:(
rType, {Request type}
cxCell, {Columns per cell (cell width)}
cyCell:word; {Rows per cell (cell height)}
pbData:pointer; {Address of caller's buffer}
cbData:word); {Size of caller's buffer in bytes}
2:(
aType,
cxCell2,
cyCell2:word;
pbData2:longint); (* should be pbData, but this construct *)
3:(_type:word); (* is not supported currently *)
end;
PVioFontInfo=^TVioFontInfo;
VioFontInfo=TVioFontInfo; (* *)
{record types for VioGetState/VioSetState}
TVioPalState=record
@ -445,6 +475,7 @@ type
AColor:array[0..15] of word; {Up to 16 register values}
end;
PVioPalState=^TVioPalState;
VioPalState=TVioPalState;
TVioOverscan=record
cb:word; {Size of the record}
@ -452,6 +483,7 @@ type
Color:word; {The colour of the border area}
end;
PVioOverscan=^TVioOverscan;
VioOverScan=TVioOverScan;
TVioIntensity=record
cb:word; {Size of the record}
@ -459,6 +491,7 @@ type
fs:word; {The flink/bold background switch}
end;
PVioIntensity=^TVioIntensity;
VioIntensity=TVioIntensity;
TVioColorReg=record
cb:word; {Size of the record}
@ -468,6 +501,7 @@ type
ColorRegAddr:pointer; {pointer to an array with colour values}
end;
PVioColorReg=^TVioColorReg;
VioColorReg=TVioColorReg;
TVioSetULineLoc=record
cb:word; {Size of the record}
@ -475,6 +509,7 @@ type
ScanLine:word; {Location of the underline (32=no underline)}
end;
PVioSetULineLoc=^TVioSetULineLoc;
VioSetULineLoc=TVioSetULineLoc;
TVioSetTarget=record
cb:word; {Size of the record}
@ -483,6 +518,7 @@ type
{(see VIO_CONFIG_* constants)}
end;
PVioSetTarget=^TVioSetTarget;
VioSetTarget=TVioSetTarget;
TStr8=array[0..7] of char;
PStr8=^TStr8;
@ -501,6 +537,7 @@ type
fsFontUse:word;
end;
PFAttrs=^TFAttrs;
FAttrs=TFAttrs;
{font metrics returned by GpiQueryFonts and others}
TPanose=record
@ -517,6 +554,7 @@ type
fbPassedISO:byte;
fbFailedISO:byte;
end;
PPanose=^TPanose;
TFontMetrics=record
szFamilyname:array[0..FACESIZE-1] of char;
@ -573,6 +611,7 @@ type
Panose:TPanose;
end;
PFontMetrics=^TFontMetrics;
FontMetrics=TFontMetrics;
function VioRegister(ModuleName,ProcName:PChar;FnMask1,FnMask2:cardinal):word;
@ -1058,3 +1097,4 @@ external 'EMXWRAP' index 30;
{external 'PMVIOP' index 30;}
end.