3895 lines
140 KiB
ObjectPascal
3895 lines
140 KiB
ObjectPascal
(***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is TurboPower Async Professional
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* TurboPower Software
|
|
*
|
|
* Portions created by the Initial Developer are Copyright (C) 1991-2002
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Sulaiman Mah
|
|
* Sean B. Durkin
|
|
* Sebastian Zierer
|
|
*
|
|
* ***** END LICENSE BLOCK ***** *)
|
|
|
|
{*********************************************************}
|
|
{* OOMISC.PAS 5.00 *}
|
|
{*********************************************************}
|
|
{* Miscellaneous supporting methods and types *}
|
|
{*********************************************************}
|
|
|
|
{
|
|
OOMisc is our catch-all unit for supporting methods and definitions.
|
|
OOMisc is used by almost all APRO units, and is automatically included
|
|
in the uses clause when an APRO component is dropped on a form.
|
|
The APRO base classes are defined here also.
|
|
A bit of APRO trivia: OOMisc stands for "Object Oriented Miscellaneous",
|
|
and was introduced in the early DOS days.
|
|
}
|
|
|
|
{Global defines potentially affecting this unit}
|
|
{$I AWDEFINE.INC}
|
|
|
|
unit OoMisc;
|
|
{-Unit for miscellaneous routines}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows,
|
|
Classes,
|
|
Controls,
|
|
ShellAPI,
|
|
OleCtrls,
|
|
Forms,
|
|
Graphics,
|
|
MMSystem,
|
|
SysUtils,
|
|
Messages;
|
|
|
|
const
|
|
ApVersionStr = 'v5.00';
|
|
{$IFDEF Apax}
|
|
ApaxVersionStr = 'v1.14'; // SWB
|
|
{$ENDIF}
|
|
|
|
{ Product name}
|
|
ApdProductName = 'Async Professional';
|
|
ApdShortProductName = 'APRO';
|
|
|
|
ApdVendor = 'TurboPower Software Company';
|
|
ApdVendorURL = 'http://www.TurboPower.com';
|
|
|
|
{ Version numbers }
|
|
ApdXSLImplementation = 0.0;
|
|
ApdXMLSpecification = '1.0';
|
|
|
|
fsPathName = 255;
|
|
fsDirectory = 255;
|
|
fsFileName = 255;
|
|
fsExtension = 255;
|
|
fsName = 255;
|
|
|
|
{shareable reading file mode}
|
|
ApdShareFileRead = $40;
|
|
|
|
const
|
|
{ Printer driver consts }
|
|
ApdDefFileName = 'C:\DEFAULT.APF';
|
|
ApdPipeTimeout = 5000; { ms }
|
|
ApdPipeName = '\\.\pipe\ApFaxCnv';
|
|
ApdSemaphoreName = 'ApFaxCnvSem';
|
|
ApdRegKey = '\SOFTWARE\TurboPower\ApFaxCnv\Settings';
|
|
ApdIniFileName = 'APFPDENG.INI';
|
|
ApdIniSection = 'Settings';
|
|
ApdIniKey = 'AutoExec';
|
|
ApdDef32PrinterName = 'APF Fax Printer';
|
|
ApdDef16PrinterName = 'Print To Fax';
|
|
ApdDefPrinterPort = 'PRINTFAX';
|
|
|
|
ApdDefaultTerminalName = '<default>';
|
|
ApdNoTerminalName = '<none>';
|
|
|
|
|
|
{Event codes: (inbound)}
|
|
eNull = 0;
|
|
eStartDoc = 1;
|
|
eEndDoc = 2;
|
|
|
|
{Event codes: (outbound)}
|
|
eSetFileName = 3;
|
|
|
|
type
|
|
TPipeEvent = record
|
|
Event : Byte;
|
|
Data : ShortString;
|
|
end;
|
|
{ XML definitions }
|
|
DOMString = WideString;
|
|
type
|
|
CharSet = set of AnsiChar;
|
|
|
|
TPassString = string[255];
|
|
TApdHwnd = HWND;
|
|
|
|
|
|
{Standard event timer record structure used by all timing routines}
|
|
EventTimer = record
|
|
StartTicks : Integer; {Tick count when timer was initialized}
|
|
ExpireTicks : Integer; {Tick count when timer will expire}
|
|
end;
|
|
|
|
{$IFNDEF PRNDRV} {!!.06}
|
|
type{ moved from AdTapi.pas } {!!.06}
|
|
{ TAPI device config record, opaque and undefined by definition } {!!.06}
|
|
PTapiConfigRec = ^TTapiConfigRec; {!!.06}
|
|
TTapiConfigRec = record {!!.06}
|
|
DataSize : Cardinal; {!!.06}
|
|
Data : array[0..1023] of Byte; {!!.06}
|
|
end;
|
|
|
|
{ moved from AdRasUtl.pas } {!!.06}
|
|
const {RasMaximum buffer sizes} {!!.06}
|
|
RasMaxDomain = 15; {!!.06}
|
|
RasMaxPassword = 256; {!!.06}
|
|
RasMaxUserName = 256; {!!.06}
|
|
RasMaxEntryName = 256; {!!.06}
|
|
RasMaxPhoneBook = 256; {!!.06}
|
|
RasMaxError = 256; {!!.06}
|
|
RasMaxEntries = 64; {!!.06}
|
|
RasMaxDeviceName = 128; {!!.06}
|
|
RasMaxDeviceType = 16; {!!.06}
|
|
RasMaxPhoneNumber = 128; {!!.06}
|
|
RasMaxCallBackNum = 128; {!!.06}
|
|
RasMaxAreaCode = 10; {!!.06}
|
|
RasMaxPadType = 32; {!!.06}
|
|
RasMaxX25Address = 200; {!!.06}
|
|
RasMaxIPAddress = 15; {!!.06}
|
|
RasMaxIPXAddress = 21; {!!.06}
|
|
RasMaxFacilities = 200; {!!.06}
|
|
RasMaxUserData = 200; {!!.06}
|
|
|
|
type { moved from AdRasUtl.pas } {!!.06}
|
|
{RAS IP address - "a.b.c.d"} {!!.06}
|
|
PRasIPAddr = ^TRasIPAddr; {!!.06}
|
|
TRasIPAddr = record {!!.06}
|
|
a : byte; {!!.06}
|
|
b : byte; {!!.06}
|
|
c : byte; {!!.06}
|
|
d : byte; {!!.06}
|
|
end; {!!.06}
|
|
|
|
type { moved from AdRasUtl.pas } {!!.06}
|
|
{RAS phonebook entry properties} {!!.06}
|
|
{!!.06} {Renamed fields to sync with underlying RASENTRY structure }
|
|
{ dwOptions -> dwfOptions, dwAlternatesOffset -> dwAlternateOffset, }
|
|
{ dwNetProtocols -> dwfNetProtocols }
|
|
PRasEntry = ^TRasEntry; {!!.06}
|
|
TRasEntry = record {!!.06}
|
|
dwSize : DWord; {!!.06}
|
|
dwfOptions : DWord; {!!.06}
|
|
dwCountryID : DWord; {!!.06}
|
|
dwCountryCode : DWord; {!!.06}
|
|
szAreaCode : array[0..RasMaxAreaCode] of char; {!!.06} // tchar
|
|
szLocalPhoneNumber : array[0..RasMaxPhoneNumber] of char; {!!.06} // tchar
|
|
dwAlternateOffset : DWord; {!!.06}
|
|
IPAddr : TRasIPAddr; {!!.06}
|
|
IPAddrDns : TRasIPAddr; {!!.06}
|
|
IPAddrDnsAlt : TRasIPAddr; {!!.06}
|
|
IPAddrWins : TRasIPAddr; {!!.06}
|
|
IPAddrWinsAlt : TRasIPAddr; {!!.06}
|
|
dwFrameSize : DWord; {!!.06}
|
|
dwfNetProtocols : DWord; {!!.06}
|
|
dwFramingProtocol : DWord; {!!.06}
|
|
szScript : array[0..Max_PATH-1] of char; {!!.06} // --SZ TCHAR in ras.h, so use char here
|
|
szAutodialDll : array[0..Max_PATH-1] of char; {!!.06}
|
|
szAutodialFunc : array[0..Max_PATH-1] of char; {!!.06}
|
|
szDeviceType : array[0..RasMaxDeviceType] of char; {!!.06}
|
|
szDeviceName : array[0..RasMaxDeviceName] of char; {!!.06}
|
|
szX25PadType : array[0..RasMaxPadType] of char; {!!.06}
|
|
szX25Address : array[0..RasMaxX25Address] of char; {!!.06}
|
|
szX25Facilities : array[0..RasMaxFacilities] of char; {!!.06}
|
|
szX25UserData : array[0..RasMaxUserData] of char; {!!.06}
|
|
dwChannels : DWord; {!!.06}
|
|
dwReserved1 : DWord; {!!.06}
|
|
dwReserved2 : DWord; {!!.06}
|
|
end; {!!.06}
|
|
|
|
const {RASENTRY 'dwfOptions' bit flags} {!!.06}
|
|
RASEO_UseCountryAndAreaCodes = $00000001; {!!.06}
|
|
RASEO_SpecificIpAddr = $00000002; {!!.06}
|
|
RASEO_SpecificNameServers = $00000004; {!!.06}
|
|
RASEO_IpHeaderCompression = $00000008; {!!.06}
|
|
RASEO_RemoteDefaultGateway = $00000010; {!!.06}
|
|
RASEO_DisableLcpExtensions = $00000020; {!!.06}
|
|
RASEO_TerminalBeforeDial = $00000040; {!!.06}
|
|
RASEO_TerminalAfterDial = $00000080; {!!.06}
|
|
RASEO_ModemLights = $00000100; {!!.06}
|
|
RASEO_SwCompression = $00000200; {!!.06}
|
|
RASEO_RequireEncryptedPw = $00000400; {!!.06}
|
|
RASEO_RequireMsEncryptedPw = $00000800; {!!.06}
|
|
RASEO_RequireDataEncryption = $00001000; {!!.06}
|
|
RASEO_NetworkLogon = $00002000; {!!.06}
|
|
RASEO_UseLogonCredentials = $00004000; {!!.06}
|
|
RASEO_PromoteAlternates = $00008000; {!!.06}
|
|
RASEO_SecureLocalFiles = $00010000; {!!.06}
|
|
RASEO_RequireEAP = $00020000; {!!.06}
|
|
RASEO_RequirePAP = $00040000; {!!.06}
|
|
RASEO_RequireSPAP = $00080000; {!!.06}
|
|
RASEO_Custom = $00100000; {!!.06}
|
|
RASEO_PreviewPhoneNumber = $00200000; {!!.06}
|
|
RASEO_SharedPhoneNumbers = $00800000; {!!.06}
|
|
RASEO_PreviewUserPw = $01000000; {!!.06}
|
|
RASEO_PreviewDomain = $02000000; {!!.06}
|
|
RASEO_ShowDialingProgress = $04000000; {!!.06}
|
|
RASEO_RequireCHAP = $08000000; {!!.06}
|
|
RASEO_RequireMsCHAP = $10000000; {!!.06}
|
|
RASEO_RequireMsCHAP2 = $20000000; {!!.06}
|
|
RASEO_RequireW95MSCHAP = $40000000; {!!.06}
|
|
RASEO_CustomScript = $80000000; {!!.06}
|
|
|
|
{RASENTRY 'dwfNetProtocols' bit flags} {!!.06}
|
|
RASNP_NetBEUI = $00000001; {!!.06}
|
|
RASNP_Ipx = $00000002; {!!.06}
|
|
RASNP_Ip = $00000004; {!!.06}
|
|
|
|
{RASENTRY 'dwFramingProtocols' bit flags} {!!.06}
|
|
RASFP_Ppp = $00000001; {!!.06}
|
|
RASFP_Slip = $00000002; {!!.06}
|
|
RASFP_Ras = $00000004; {!!.06}
|
|
|
|
{RASENTRY 'szDeviceType' default strings} {!!.06}
|
|
RASDT_Modem = 'modem'; {!!.06}
|
|
RASDT_Isdn = 'isdn'; {!!.06}
|
|
RASDT_X25 = 'x25'; {!!.06}
|
|
RASDT_Vpn = 'vpn'; {!!.06}
|
|
RASDT_Pad = 'pad'; {!!.06}
|
|
RASDT_Generic = 'GENERIC'; {!!.06}
|
|
RASDT_Serial = 'SERIAL'; {!!.06}
|
|
RASDT_FrameRelay = 'FRAMERELAY'; {!!.06}
|
|
RASDT_Atm = 'ATM'; {!!.06}
|
|
RASDT_Sonet = 'SONET'; {!!.06}
|
|
RASDT_SW56 = 'SW56'; {!!.06}
|
|
RASDT_Irda = 'IRDA'; {!!.06}
|
|
RASDT_Parallel = 'PARALLEL'; {!!.06}
|
|
|
|
type
|
|
PRasStatistics = ^TRasStatistics; {!!.06}
|
|
TRasStatistics = record {!!.06}
|
|
dwSize : DWORD; {!!.06}
|
|
dwBytesXmited : DWORD; {!!.06}
|
|
dwBytesRcved : DWORD; {!!.06}
|
|
dwFramesXmited : DWORD; {!!.06}
|
|
dwFramesRcved : DWORD; {!!.06}
|
|
dwCrcErr : DWORD; {!!.06}
|
|
dwTimeoutErr : DWORD; {!!.06}
|
|
dwAlignmentErr : DWORD; {!!.06}
|
|
dwHardwareOverrunErr : DWORD; {!!.06}
|
|
dwFramingErr : DWORD; {!!.06}
|
|
dwBufferOverrunErr : DWORD; {!!.06}
|
|
dwCompressionRatioIn : DWORD; {!!.06}
|
|
dwCompressionRatioOut : DWORD; {!!.06}
|
|
dwBps : DWORD; {!!.06}
|
|
dwConnectDuration : DWORD; {!!.06}
|
|
end; {!!.06}
|
|
{$ENDIF} {!!.06}
|
|
const
|
|
{Compile-time configurations}
|
|
MaxComHandles = 50; {Max comm ports open at once}
|
|
DispatchBufferSize = 8192; {Size of each port's dispatch buffer}
|
|
MaxMessageLen = 80; {All error and status strings less than 80}
|
|
|
|
{For skipping line parameter changes}
|
|
DontChangeBaud = 0;
|
|
DontChangeParity = SpaceParity + 1;
|
|
DontChangeDatabits = 9;
|
|
DontChangeStopbits = TwoStopbits + 1;
|
|
|
|
{Modem status trigger options}
|
|
msCTSDelta = $0010;
|
|
msDSRDelta = $0020;
|
|
msRingDelta = $0004;
|
|
msDCDDelta = $0080;
|
|
|
|
{Line status trigger options}
|
|
lsOverrun = $0001;
|
|
lsParity = $0002;
|
|
lsFraming = $0004;
|
|
lsBreak = $0008;
|
|
|
|
{Line and driver errors}
|
|
leNoError = 0; {No error, ordinal value matches ecOK}
|
|
leBuffer = 1; {Buffer overrun in COMM.DRV}
|
|
leOverrun = 2; {UART receiver overrun}
|
|
leParity = 3; {UART receiver parity error}
|
|
leFraming = 4; {UART receiver framing error}
|
|
leCTSTO = 5; {Transmit timeout waiting for CTS}
|
|
leDSRTO = 6; {Transmit timeout waiting for DSR}
|
|
leDCDTO = 7; {Transmit timeout waiting for RLSD}
|
|
leTxFull = 8; {Transmit queue is full}
|
|
leBreak = 9; {Break condition received}
|
|
leIOError = 10; {Windows error. LastWinError contains the error code.}
|
|
|
|
{Status trigger subtypes}
|
|
stNotActive = 0; {not active}
|
|
stModem = 1; {Trigger on modem status change}
|
|
stLine = 2; {Trigger on line status change}
|
|
stOutBuffFree = 3; {Trigger on outbuff free level}
|
|
stOutBuffUsed = 4; {Trigger on outbuff used level}
|
|
stOutSent = 5; {Trigger on any PutXxx call}
|
|
|
|
{Next file method}
|
|
nfNone = 0; {No next file method specified}
|
|
nfMask = 1; {Use built-in next file mask method}
|
|
nfList = 2; {Use built-in next file list method}
|
|
|
|
{Action to take if incoming file exists}
|
|
wfcWriteNone = 0; {No option set yet}
|
|
wfcWriteFail = 1; {Fail the open attempt}
|
|
wfcWriteRename = 2; {Rename the incoming file}
|
|
wfcWriteAnyway = 3; {Overwrite the existing file}
|
|
wfcWriteResume = 4; {Resume an interrupted receive}
|
|
|
|
{Ascii CR/LF translation options}
|
|
atNone = 0; {No CR/LF translations}
|
|
atStrip = 1; {Strip CRs or LFs}
|
|
atAddCRBefore = 2; {Add CR before each LF}
|
|
atAddLFAfter = 3; {Add LF after each CR}
|
|
atEOFMarker : Ansichar = ^Z; {Add constant for standard EOF }
|
|
|
|
{Protocol status start/end flags}
|
|
apFirstCall = $01; {Indicates the first call to status}
|
|
apLastCall = $02; {Indicates the last call to status}
|
|
|
|
{For specifying log file calls}
|
|
lfReceiveStart = 0; {Receive starting}
|
|
lfReceiveOk = 1; {File received ok}
|
|
lfReceiveFail = 2; {File receive failed}
|
|
lfReceiveSkip = 3; {File was rejected by receiver}
|
|
lfTransmitStart = 4; {Transmit starting}
|
|
lfTransmitOk = 5; {File was transmitted ok}
|
|
lfTransmitFail = 6; {File transmit failed}
|
|
lfTransmitSkip = 7; {File was skipped, rejected by receiver}
|
|
|
|
type
|
|
{Convenient types used by protocols}
|
|
TNameCharArray = array[0..fsFileName ] of AnsiChar; //SZ used by protocols --> Ansi
|
|
TExtCharArray = array[0..fsExtension] of AnsiChar;
|
|
TPathCharArray = array[0..fsPathName ] of Char;
|
|
TPathCharArrayA = array[0..fsPathName ] of AnsiChar; //SZ FIXME can this be changed to Char??
|
|
TDirCharArray = array[0..fsDirectory] of AnsiChar;
|
|
TChar20Array = array[0..20] of AnsiChar;
|
|
TCharArray = array[0..255] of AnsiChar;
|
|
|
|
{For generic buffer typecasts}
|
|
PByteBuffer = ^TByteBuffer;
|
|
TByteBuffer = array[1..65535] of Byte;
|
|
|
|
{Port characteristic constants}
|
|
TDatabits = 5..DontChangeDatabits;
|
|
TStopbits = 1..DontChangeStopbits;
|
|
|
|
{NotifyProc type, same as a window procedure}
|
|
TApdNotifyProc = procedure(Msg, wParam : Cardinal;
|
|
lParam : Integer);
|
|
TApdNotifyEvent = procedure(Msg, wParam : Cardinal;
|
|
lParam : Integer) of object;
|
|
const
|
|
{Avoid requiring WIN31}
|
|
ev_CTSS = $0400; {CTS state}
|
|
ev_DSRS = $0800; {DSR state}
|
|
ev_RLSDS = $1000; {RLSD state}
|
|
ev_RingTe = $2000; {Ring trailing edge indicator}
|
|
|
|
const
|
|
{MSRShadow register from COMM.DRV}
|
|
MsrShadowOfs = 35; {Offset of MSRShadow from EventWord}
|
|
|
|
const
|
|
{Modem status bit masks}
|
|
DeltaCTSMask = $01; {CTS changed since last read}
|
|
DeltaDSRMask = $02; {DSR changed since last read}
|
|
DeltaRIMask = $04; {RI changed since last read}
|
|
DeltaDCDMask = $08; {DCD changed since last read}
|
|
CTSMask = $10; {Clear to send}
|
|
DSRMask = $20; {Data set ready}
|
|
RIMask = $40; {Ring indicator}
|
|
DCDMask = $80; {Data carrier detect}
|
|
|
|
const
|
|
{Message base}
|
|
apw_First = $7E00; {Sets base for all APW messages}
|
|
|
|
const
|
|
{Custom message types}
|
|
apw_TriggerAvail = apw_First+1; {Trigger for any data avail}
|
|
apw_TriggerData = apw_First+2; {Trigger data}
|
|
apw_TriggerTimer = apw_First+3; {Trigger timer}
|
|
apw_TriggerStatus = apw_First+4; {Status change (modem, line, buffer)}
|
|
apw_FromYmodem = apw_First+5; {Tells Xmodem it was called from Ymodem}
|
|
apw_PortOpen = apw_First+8; {Apro, tell users port open}
|
|
apw_PortClose = apw_First+9; {Apro, tell users port closed}
|
|
apw_ClosePending = apw_First+10; {Apro, tell ourself that the port was closed}
|
|
|
|
const
|
|
{Protocol message types}
|
|
apw_ProtocolCancel = apw_First+20; {To protocol - chk for protcl abort}
|
|
apw_ProtocolStatus = apw_First+21; {From protocol - update status display}
|
|
apw_ProtocolLog = apw_First+22; {From protocol - LogFile message}
|
|
apw_ProtocolNextFile = apw_First+23; {From protocol - return next file}
|
|
apw_ProtocolAcceptFile = apw_First+24; {From protocol - accept file}
|
|
apw_ProtocolFinish = apw_First+25; {From protocol - protocol is finished}
|
|
apw_ProtocolResume = apw_First+26; {From protocol - resume request}
|
|
apw_ProtocolError = apw_First+27; {From protocol - error during protocol}
|
|
apw_ProtocolAbort = apw_First+28; {To protocol - abort the transfer}
|
|
|
|
const
|
|
{Modem message types}
|
|
apw_AutoAnswer = apw_First+40; {To modem, enter AutoAnswer}
|
|
apw_CancelCall = apw_First+41; {To modem, cancel the call}
|
|
apw_StartDial = apw_First+42; {To modem, start the process}
|
|
|
|
{deprecated modem message types, note that some conflict with new messages}
|
|
apw_ModemOk = apw_First+40; {From modem - got OK response}
|
|
apw_ModemConnect = apw_First+41; {From modem - got CONNECT response}
|
|
apw_ModemBusy = apw_First+42; {From modem - got BUSY response}
|
|
apw_ModemVoice = apw_First+43; {From modem - got VOICE response}
|
|
apw_ModemNoCarrier = apw_First+44; {From modem - got NO CARRIER response}
|
|
apw_ModemNoDialTone = apw_First+45; {From modem - got NO DIALTONE response}
|
|
apw_ModemError = apw_First+46; {From modem - got ERROR response}
|
|
apw_GotLineSpeed = apw_First+47; {From modem - got connect speed}
|
|
apw_GotErrCorrection = apw_First+48; {From modem - got EC response}
|
|
apw_GotDataCompression = apw_First+49; {From modem - got compression response}
|
|
apw_CmdTimeout = apw_First+50; {From modem - command timed out}
|
|
apw_DialTimeout = apw_First+51; {From modem - dial timed out}
|
|
apw_AnswerTimeout = apw_First+52; {From modem - answer timed out}
|
|
apw_DialCount = apw_First+53; {From modem - dial still in progress}
|
|
apw_AnswerCount = apw_First+54; {From modem - answer still in progress}
|
|
apw_ModemRing = apw_First+55; {From modem - phone rang}
|
|
apw_ModemIsConnected = apw_First+56; {From modem - connection completed}
|
|
apw_ConnectFailed = apw_First+57; {From modem - connection failed}
|
|
apw_CommandProcessed = apw_First+58; {From modem - finished command}
|
|
|
|
const
|
|
{Terminal message types}
|
|
apw_TermStart = apw_First+60; {To terminal - start}
|
|
apw_TermStop = apw_First+61; {To terminal - stop}
|
|
apw_TermSetCom = apw_First+62; {To terminal - set com handle}
|
|
apw_TermRelCom = apw_First+63; {To terminal - release com handle}
|
|
apw_TermSetEmuPtr = apw_First+64; {To terminal - set emulator pointer}
|
|
apw_TermSetEmuProc = apw_First+65; {To terminal - set emulator proc}
|
|
apw_TermClear = apw_First+66; {To terminal - clear window}
|
|
apw_TermBuffer = apw_First+67; {To terminal - alloc new buffers}
|
|
apw_TermColors = apw_First+68; {To terminal - set new colors}
|
|
apw_TermToggleScroll = apw_First+69; {To terminal - toggle scrollback}
|
|
apw_TermCapture = apw_First+70; {To terminal - set capture mode}
|
|
apw_TermStuff = apw_First+71; {To terminal - stuff data}
|
|
apw_TermPaint = apw_First+72; {To terminal - update screen}
|
|
apw_TermSetWndProc = apw_First+73; {To terminal - set window proc}
|
|
apw_TermColorsH = apw_First+74; {To terminal - set highlight colors}
|
|
apw_TermSave = apw_First+75; {To terminal - save/restore}
|
|
apw_TermColorMap = apw_First+76; {To terminal - get/set color map}
|
|
apw_TermForceSize = apw_First+77; {To terminal - force new size}
|
|
apw_TermFontSize = apw_First+78; {To terminal - get font size}
|
|
|
|
const
|
|
apw_TermStatus = apw_First+80; {From terminal - show status}
|
|
apw_TermBPlusStart = apw_First+81; {From terminal - B+ is starting}
|
|
apw_TermError = apw_First+82; {From terminal - error}
|
|
apw_CursorPosReport = apw_First+83; {From terminal - Cursor Pos Report}
|
|
|
|
const
|
|
apw_FaxCvtStatus = apw_First+90; {From fax converter - show status}
|
|
apw_FaxUnpStatus = apw_First+91; {From fax unpacker - show status}
|
|
apw_FaxOutput = apw_First+92; {From fax unpacker - output line}
|
|
|
|
const
|
|
apw_ViewSetFile = apw_First+100; {To fax viewer - change file name}
|
|
apw_ViewSetFG = apw_First+101; {To fax viewer - set foreground color}
|
|
apw_ViewSetBG = apw_First+102; {To fax viewer - set background color}
|
|
apw_ViewSetScale = apw_First+103; {To fax viewer - set scale factors}
|
|
apw_ViewSetScroll = apw_First+104; {To fax viewer - set scroll increments}
|
|
apw_ViewSelectAll = apw_First+105; {To fax viewer - select entire image}
|
|
apw_ViewSelect = apw_First+106; {To fax viewer - select image rect}
|
|
apw_ViewCopy = apw_First+107; {To fax viewer - copy data to cboard}
|
|
apw_ViewSetWndProc = apw_First+108; {To fax viewer - set window procedure}
|
|
apw_ViewSetWhitespace = apw_First+109; {To fax viewer - set whitespace comp}
|
|
apw_ViewGetBitmap = apw_First+110; {To fax viewer - get memory bmp}
|
|
apw_ViewGetNumPages = apw_First+111; {To fax viewer - get num pages}
|
|
apw_ViewStartUpdate = apw_First+112; {To fax viewer - start scale update}
|
|
apw_ViewEndUpdate = apw_First+113; {To fax viewer - end scale upate}
|
|
apw_ViewGotoPage = apw_First+114; {To fax viewer - go to a page}
|
|
apw_ViewGetCurPage = apw_First+115; {To fax viewer - get current page #}
|
|
apw_ViewSetDesignMode = apw_First+116; {To fax viewer - indicate in design}
|
|
apw_ViewSetRotation = apw_First+117; {To fax viewer - set rotation}
|
|
apw_ViewSetAutoScale = apw_First+118; {To fax viewer - auto scaling}
|
|
apw_ViewNotifyPage = apw_First+119; {To fax viewer - notify of page chg}
|
|
apw_ViewGetPageDim = apw_First+120; {To fax viewer - get pg dimensions}
|
|
apw_ViewSetLoadWholeFax= apw_First+121; {To fax viewer - set load whole fax}
|
|
apw_ViewSetBusyCursor = apw_First+122; {To fax viewer - set cursor for busy}
|
|
apw_ViewerError = apw_First+123; {Fax viewer error report}
|
|
apw_ViewGetPageFlags = apw_First+124; {To fax viewer - get pg flags}
|
|
apw_ViewGetFileName = apw_First+125; {To fax viewer - get file name}
|
|
|
|
const
|
|
apw_TermBlinkTimeChange = apw_First+130; {set new blink time}
|
|
apw_TermPersistentMarkChange = apw_First+131; {set persistent blocks}
|
|
apw_TermSetKeyEmuPtr = apw_First+132; {set Key Emulator pointer }
|
|
apw_TermSetKeyEmuProc = apw_First+133; {set Key Emulator proc }
|
|
apw_TermSetHalfDuplex = apw_First+134; {set Duplex mode}
|
|
apw_TermGetBuffPtr = apw_First+135; {get a pointer to term buffer}
|
|
apw_TermGetClientLine = apw_First+136; {get the first client line in buffer}
|
|
apw_TermWaitForPort = apw_First+137; {wait for the port to open}{!!.03}
|
|
apw_TermNeedsUpdate = apw_First+138; {update needed} {!!.05}
|
|
|
|
const
|
|
apw_PrintDriverJobCreated = apw_First+140; {printer driver created fax job}
|
|
apw_BeginDoc = apw_First+141; {printer driver starts printing}
|
|
apw_EndDoc = apw_First+142; {printer driver has finished printing}
|
|
apw_AddPrim = apw_First+143; {internal FaxSrvx sample message}
|
|
apw_EndPage = apw_First+144; {printer driver EndOfPage/idShell}
|
|
|
|
const
|
|
apw_FaxCancel = apw_First+160; {To fax - cancel the session}
|
|
apw_FaxNextfile = apw_First+161; {From fax - return next fax to send}
|
|
apw_FaxStatus = apw_First+162; {From fax - show the fax status}
|
|
apw_FaxLog = apw_First+163; {From fax - log the fax start/stop}
|
|
apw_FaxName = apw_First+164; {From fax - name the incoming fax}
|
|
apw_FaxAccept = apw_First+165; {From fax - accept this fax?}
|
|
apw_FaxError = apw_First+166; {From fax - session had error}
|
|
apw_FaxFinish = apw_First+167; {From fax - session finished}
|
|
|
|
const
|
|
apw_TapiWaveMessage = apw_First+180; {Tapi wave event message}
|
|
apw_TapiEventMessage = apw_First+181; {Tapi general event message}
|
|
apw_VoIPEventMessage = apw_First+182; {AdVoIP general event message}
|
|
apw_VoIPNotifyMessage = apw_First+183; {AdVoIP internal notification message}
|
|
|
|
const
|
|
apw_StateDeactivate = apw_First+190; {State deactivation message }
|
|
apw_StateChange = apw_First+191; {from State to StateMachine }
|
|
|
|
const
|
|
apw_SapiTrain = apw_First+192; {Sapi training requested}
|
|
apw_SapiPhoneCallBack = apw_First+193; {Sapi AskFor phrase return}
|
|
apw_SapiInfoPhrase = apw_First+194; {Sapi TAPI connection status}
|
|
|
|
const
|
|
apw_PgrStatusEvent = apw_First+200; {Pager status event}
|
|
|
|
const
|
|
{Window class names}
|
|
DispatcherClassName = 'awDispatch';
|
|
ProtocolClassName = 'awProtocol';
|
|
TerminalClassName = 'awTerminal';
|
|
MessageHandlerClassName = 'awMsgHandler';
|
|
FaxViewerClassName = 'awViewer';
|
|
FaxViewerClassNameDesign = 'dcViewer';
|
|
TerminalClassNameDesign = 'dcTerminal';
|
|
FaxHandlerClassName = 'awFaxHandler';
|
|
|
|
const
|
|
{Error groups}
|
|
egDos = -0; {DOS, DOS critical and file I/O}
|
|
egGeneral = -1; {General errors}
|
|
egOpenComm = -2; {OpenComm errors}
|
|
egSerialIO = -3; {Errors during serial I/O processing}
|
|
egModem = -4; {Errors during modem processing}
|
|
egTrigger = -5; {Error setting up triggers}
|
|
egProtocol = -6; {Errors that apply to one or more protocols}
|
|
egINI = -7; {INI database errors}
|
|
egFax = -8; {FAX errors}
|
|
egAdWinsock = 9; {APro specific Winsock errors}
|
|
egWinsock = 10; {Winsock errors}
|
|
egWinsockEx = 11; {Additional Winsock errors}
|
|
egTapi = -13; {TAPI errors}
|
|
|
|
const
|
|
{ Below are all error codes used by APRO -- resource IDs are Abs(ErrorCode) }
|
|
{ The corresponding strings can be found in APW.STR and AdExcept.inc. If }
|
|
{ you are adding strings, it's best to go there first to 'stake a claim' on }
|
|
{ an appropriate range of IDs -- since constants for some status strings }
|
|
{ are found in the applicable component's unit instead of here... }
|
|
|
|
{No error}
|
|
ecOK = 0; {Okay}
|
|
|
|
const
|
|
{egDOS}
|
|
ecFileNotFound = -2; {File not found}
|
|
ecPathNotFound = -3; {Path not found}
|
|
ecTooManyFiles = -4; {Too many open files}
|
|
ecAccessDenied = -5; {File access denied}
|
|
ecInvalidHandle = -6; {Invalid file handle}
|
|
ecOutOfMemory = -8; {Insufficient memory}
|
|
ecInvalidDrive = -15; {Invalid drive}
|
|
ecNoMoreFiles = -18; {No more files}
|
|
ecDiskRead = -100; {Attempt to read beyond end of file}
|
|
ecDiskFull = -101; {Disk is full}
|
|
ecNotAssigned = -102; {File not Assign-ed}
|
|
ecNotOpen = -103; {File not open}
|
|
ecNotOpenInput = -104; {File not open for input}
|
|
ecNotOpenOutput = -105; {File not open for output}
|
|
ecWriteProtected = -150; {Disk is write-protected}
|
|
ecUnknownUnit = -151; {Unknown disk unit}
|
|
ecDriveNotReady = -152; {Drive is not ready}
|
|
ecUnknownCommand = -153; {Unknown command}
|
|
ecCrcError = -154; {Data error}
|
|
ecBadStructLen = -155; {Bad request structure length}
|
|
ecSeekError = -156; {Seek error}
|
|
ecUnknownMedia = -157; {Unknown media type}
|
|
ecSectorNotFound = -158; {Disk sector not found}
|
|
ecOutOfPaper = -159; {Printer is out of paper}
|
|
ecDeviceWrite = -160; {Device write error}
|
|
ecDeviceRead = -161; {Device read error}
|
|
ecHardwareFailure = -162; {General failure}
|
|
|
|
const
|
|
{egGeneral}
|
|
ecBadHandle = -1001; {Bad handle passed to com function}
|
|
ecBadArgument = -1002; {Bad argument passed to function}
|
|
ecGotQuitMsg = -1003; {Yielding routine got WM_QUIT message}
|
|
ecBufferTooBig = -1004; {Terminal buffer size too big}
|
|
ecPortNotAssigned = -1005; {ComPort component not assigned}
|
|
ecInternal = -1006; {Internal INIDB errors}
|
|
ecModemNotAssigned = -1007; {Modem component not assigned}
|
|
ecPhonebookNotAssigned = -1008; {Phonebook component not assgnd}
|
|
ecCannotUseWithWinSock = -1009; {Component not compatible with WinSock}
|
|
|
|
const
|
|
{egOpenComm}
|
|
ecBadId = -2001; {ie_BadId - bad or unsupported ID}
|
|
ecBaudRate = -2002; {ie_Baudrate - unsupported baud rate}
|
|
ecByteSize = -2003; {ie_Bytesize - invalid byte size}
|
|
ecDefault = -2004; {ie_Default - error in default parameters}
|
|
ecHardware = -2005; {ie_Hardware - hardware not present}
|
|
ecMemory = -2006; {ie_Memory - unable to allocate queues}
|
|
ecCommNotOpen = -2007; {ie_NOpen - device not open}
|
|
ecAlreadyOpen = -2008; {ie_Open - device already open}
|
|
ecNoHandles = -2009; {No more handles, can't open port}
|
|
ecNoTimers = -2010; {No timers available}
|
|
ecNoPortSelected = -2011; {No port selected (attempt to open com0)}
|
|
ecNotOpenedByTapi = -2012; {Comport was not opened by Tapi}
|
|
|
|
const
|
|
{egSerialIO}
|
|
ecNullApi = -3001; {No device layer specified}
|
|
ecNotSupported = -3002; {Function not supported by driver}
|
|
ecRegisterHandlerFailed = -3003; {EnableCommNotification failed}
|
|
ecPutBlockFail = -3004; {Failed to put entire block}
|
|
ecGetBlockFail = -3005; {Failed to get entire block}
|
|
ecOutputBufferTooSmall = -3006; {Output buffer too small for block}
|
|
ecBufferIsEmpty = -3007; {Buffer is empty}
|
|
ecTracingNotEnabled = -3008; {Tracing not enabled}
|
|
ecLoggingNotEnabled = -3009; {Logging not enabled}
|
|
ecBaseAddressNotSet = -3010; {Base addr not found, RS485 mode}
|
|
|
|
const
|
|
{Modem/Pager}
|
|
ecModemNotStarted = -4001; {StartModem has not been called}
|
|
ecModemBusy = -4002; {Modem is busy elsewhere}
|
|
ecModemNotDialing = -4003; {Modem is not currently dialing}
|
|
ecNotDialing = -4004; {TModemDialer is not dialing}
|
|
ecAlreadyDialing = -4005; {TModemdialer is already dialing}
|
|
ecModemNotResponding = -4006; {No response from modem}
|
|
ecModemRejectedCommand = -4007; {Bad command sent to modem}
|
|
ecModemStatusMismatch = -4008; {Wrong modem status requested}
|
|
|
|
ecDeviceNotSelected = -4009; { Um, the modem wan't selected }
|
|
ecModemDetectedBusy = -4010; { Modem detected busy signal }
|
|
ecModemNoDialtone = -4011; { No dialtone detected }
|
|
ecModemNoCarrier = -4012; { No carrier from modem }
|
|
ecModemNoAnswer = -4013; { Modem returned No Answer response }
|
|
|
|
{ Pager }
|
|
ecInitFail = -4014; { Modem initialization failure }
|
|
ecLoginFail = -4015; { Login Failure }
|
|
ecMinorSrvErr = -4016; { SNPP - Minor Server Error }
|
|
ecFatalSrvErr = -4017; { SNPP - Fatal Server Error }
|
|
|
|
const
|
|
{LibModem}
|
|
ecModemNotFound = -4020; { Modem not found in modemcap }
|
|
ecInvalidFile = -4021; { a modemcap file is invalid }
|
|
|
|
const {RAS connection status codes}
|
|
csOpenPort = 4500;
|
|
csPortOpened = 4501;
|
|
csConnectDevice = 4502;
|
|
csDeviceConnected = 4503;
|
|
csAllDevicesConnected = 4504;
|
|
csAuthenticate = 4505;
|
|
csAuthNotify = 4506;
|
|
csAuthRetry = 4507;
|
|
csAuthCallback = 4508;
|
|
csAuthChangePassword = 4509;
|
|
csAuthProject = 4510;
|
|
csAuthLinkSpeed = 4511;
|
|
csAuthAck = 4512;
|
|
csReAuthenticate = 4513;
|
|
csAuthenticated = 4514;
|
|
csPrepareForCallback = 4515;
|
|
csWaitForModemReset = 4516;
|
|
csWaitForCallback = 4517;
|
|
csProjected = 4518;
|
|
|
|
csStartAuthentication = 4519;
|
|
csCallbackComplete = 4520;
|
|
csLogonNetwork = 4521;
|
|
csSubEntryConnected = 4522;
|
|
csSubEntryDisconnected = 4523;
|
|
csRasInteractive = 4550;
|
|
csRasRetryAuthentication = 4551;
|
|
csRasCallbackSetByCaller = 4552;
|
|
csRasPasswordExpired = 4553;
|
|
csRasDeviceConnected = 4599;
|
|
csRasBaseEnd = csSubEntryDisconnected;
|
|
csRasPaused = $1000;
|
|
csInteractive = csRasPaused;
|
|
csRetryAuthentication = csRasPaused + 1;
|
|
csCallbackSetByCaller = csRasPaused + 2;
|
|
csPasswordExpired = csRasPaused + 3;
|
|
csRasPausedEnd = csRasPaused + 3;
|
|
|
|
csRasConnected = $2000;
|
|
csRasDisconnected = csRasConnected + 1;
|
|
|
|
{ Protocols }
|
|
{ If strings are added -- apStatusMsg needs to be changed in AWABSPCL.PAS }
|
|
|
|
const
|
|
psOK = 4700; {Protocol is ok}
|
|
psProtocolHandshake = 4701; {Protocol handshaking in progress}
|
|
psInvalidDate = 4702; {Bad date/time stamp received and ignored}
|
|
psFileRejected = 4703; {Incoming file was rejected}
|
|
psFileRenamed = 4704; {Incoming file was renamed}
|
|
psSkipFile = 4705; {Incoming file was skipped}
|
|
psFileDoesntExist = 4706; {Incoming file doesn't exist locally, skipped}
|
|
psCantWriteFile = 4707; {Incoming file skipped due to Zmodem options}
|
|
psTimeout = 4708; {Timed out waiting for something}
|
|
psBlockCheckError = 4709; {Bad checksum or CRC}
|
|
psLongPacket = 4710; {Block too long}
|
|
psDuplicateBlock = 4711; {Duplicate block received and ignored}
|
|
psProtocolError = 4712; {Error in protocol}
|
|
psCancelRequested = 4713; {Cancel requested}
|
|
psEndFile = 4714; {At end of file}
|
|
psResumeBad = 4715; {B+ host refused resume request}
|
|
psSequenceError = 4716; {Block was out of sequence}
|
|
psAbortNoCarrier = 4717; {Aborting on carrier loss}
|
|
psAbort = 4730; {Session aborted}
|
|
|
|
const
|
|
{Specific to certain protocols}
|
|
psGotCrcE = 4718; {Got CrcE packet (Zmodem)}
|
|
psGotCrcG = 4719; {Got CrcG packet (Zmodem)}
|
|
psGotCrcW = 4720; {Got CrcW packet (Zmodem)}
|
|
psGotCrcQ = 4721; {Got CrcQ packet (Zmodem)}
|
|
psTryResume = 4722; {B+ is trying to resume a download}
|
|
psHostResume = 4723; {B+ host is resuming}
|
|
psWaitAck = 4724; {Waiting for B+ ack (internal)}
|
|
|
|
const
|
|
{Internal}
|
|
psNoHeader = 4725; {Protocol is waiting for header (internal)}
|
|
psGotHeader = 4726; {Protocol has header (internal)}
|
|
psGotData = 4727; {Protocol has data packet (internal)}
|
|
psNoData = 4728; {Protocol doesn't have data packet yet (internal)}
|
|
|
|
{ Constants for fax strings }
|
|
{ If strings are added -- afStatusMsg needs to be changed in AWABSFAX.PAS }
|
|
const
|
|
{Fax progress codes, sending}
|
|
fpInitModem = 4801; {Initializing modem for fax processing}
|
|
fpDialing = 4802; {Dialing}
|
|
fpBusyWait = 4803; {Busy, FaxTransmit is waiting}
|
|
fpSendPage = 4804; {Sending document page data}
|
|
fpSendPageStatus = 4805; {Send EOP}
|
|
fpPageError = 4806; {Error sending page}
|
|
fpPageOK = 4807; {Page accepted by remote}
|
|
fpConnecting = 4808; {Send call handoff connecting}
|
|
|
|
const
|
|
{Fax progress codes, receiving}
|
|
fpWaiting = 4820; {Waiting for incoming call}
|
|
fpNoConnect = 4821; {No connect on this call}
|
|
fpAnswer = 4822; {Answering incoming call}
|
|
fpIncoming = 4823; {Incoming call validated as fax}
|
|
fpGetPage = 4824; {Getting page data}
|
|
fpGetPageResult = 4825; {Getting end-of-page signal}
|
|
fpCheckMorePages = 4826; {getting end-of-document status}
|
|
fpGetHangup = 4827; {Get hangup command}
|
|
fpGotHangup = 4828; {Got Class 2 FHNG code}
|
|
|
|
const
|
|
{Fax server codes }
|
|
fpSwitchModes = 4830; {Switching from send/recv or recv/send}
|
|
fpMonitorEnabled = 4831; {Monitoring for incoming faxes}
|
|
fpMonitorDisabled = 4832; {Not monitoring for incoming faxes}
|
|
|
|
const
|
|
{Fax progress codes, common}
|
|
fpSessionParams = 4840; {Getting connection params}
|
|
fpGotRemoteID = 4841; {got called-station ID}
|
|
fpCancel = 4842; {User abort}
|
|
fpFinished = 4843; {Finished with this fax}
|
|
|
|
const
|
|
{Trigger errors}
|
|
ecNoMoreTriggers = -5001; {No more trigger slots}
|
|
ecTriggerTooLong = -5002; {Data trigger too long}
|
|
ecBadTriggerHandle = -5003; {Bad trigger handle}
|
|
|
|
const
|
|
{Packet errors}
|
|
ecStartStringEmpty = -5501; {Start string is empty}
|
|
ecPacketTooSmall = -5502; {Packet size cannot be smaller than start string}
|
|
ecNoEndCharCount = -5503; {CharCount packets must have an end-condition}
|
|
ecEmptyEndString = -5504; {End string is empty}
|
|
ecZeroSizePacket = -5505; {Packet size cannot be zero}
|
|
ecPacketTooLong = -5506; {Packet too long}
|
|
|
|
const
|
|
{Protocol errors}
|
|
ecBadFileList = -6001; {Bad format in file list}
|
|
ecNoSearchMask = -6002; {No search mask specified during transmit}
|
|
ecNoMatchingFiles = -6003; {No files matched search mask}
|
|
ecDirNotFound = -6004; {Directory in search mask doesn't exist}
|
|
ecCancelRequested = -6005; {Cancel requested}
|
|
ecTimeout = -6006; {Fatal time out}
|
|
ecProtocolError = -6007; {Unrecoverable event during protocol}
|
|
ecTooManyErrors = -6008; {Too many errors during protocol}
|
|
ecSequenceError = -6009; {Block sequence error in Xmodem}
|
|
ecNoFilename = -6010; {No filename specified in protocol receive}
|
|
ecFileRejected = -6011; {File was rejected}
|
|
ecCantWriteFile = -6012; {Cant write file}
|
|
ecTableFull = -6013; {Kermit window table is full, fatal error}
|
|
ecAbortNoCarrier = -6014; {Aborting due to carrier loss}
|
|
ecBadProtocolFunction = -6015; {Function not support by protocol}
|
|
ecProtocolAbort = -6016; {Session aborted}
|
|
|
|
const
|
|
{INI database}
|
|
ecKeyTooLong = -7001; {Key string too long}
|
|
ecDataTooLarge = -7002; {Data string too long}
|
|
ecNoFieldsDefined = -7003; {No fields defined in database}
|
|
ecIniWrite = -7004; {Generic INI file write error}
|
|
ecIniRead = -7005; {Generic INI file read error}
|
|
ecNoIndexKey = -7006; {No index defined for database}
|
|
ecRecordExists = -7007; {Record already exists}
|
|
ecRecordNotFound = -7008; {Record not found in database}
|
|
ecMustHaveIdxVal = -7009; {Invalid index key name}
|
|
ecDatabaseFull = -7010; {Maximum database records (999) reached}
|
|
ecDatabaseEmpty = -7011; {No records in database}
|
|
ecDatabaseNotPrepared = -7012; {iPrepareIniDatabase not called}
|
|
ecBadFieldList = -7013; {Bad field list in INIDB}
|
|
ecBadFieldForIndex = -7014; {Bad field for index in INIDB}
|
|
|
|
const {!!.04}
|
|
{State Machine} {!!.04}
|
|
ecNoStateMachine = -7500; {No state machine} {!!.04}
|
|
ecNoStartState = -7501; {StartState not set} {!!.04}
|
|
ecNoSapiEngine = -7502; {SAPI Engine not set} {!!.04}
|
|
|
|
const
|
|
ecFaxBadFormat = -8001; {File is not an APF file}
|
|
ecBadGraphicsFormat = -8002; {Unsupported graphics file format}
|
|
ecConvertAbort = -8003; {User aborted fax conversion}
|
|
ecUnpackAbort = -8004; {User aborted fax unpack}
|
|
ecCantMakeBitmap = -8005; {CreateBitmapIndirect API failure}
|
|
ecNoImageLoaded = -8050; {no image loaded into viewer}
|
|
ecNoImageBlockMarked = -8051; {no block of image marked}
|
|
ecFontFileNotFound = -8052; {APFAX.FNT not found, or resource bad}
|
|
ecInvalidPageNumber = -8053; {Invalid page number specified for fax}
|
|
ecBmpTooBig = -8054; {BMP size exceeds Windows' maxheight of 32767}
|
|
ecEnhFontTooBig = -8055; {Font selected for enh text converter too large}
|
|
|
|
const
|
|
ecFaxBadMachine = -8060; {Fax incompatible with remote fax}
|
|
ecFaxBadModemResult = -8061; {Bad response from modem}
|
|
ecFaxTrainError = -8062; {Modems failed to train}
|
|
ecFaxInitError = -8063; {Error while initializing modem}
|
|
ecFaxBusy = -8064; {Called fax number was busy}
|
|
ecFaxVoiceCall = -8065; {Called fax number answered with voice}
|
|
ecFaxDataCall = -8066; {Incoming data call}
|
|
ecFaxNoDialTone = -8067; {No dial tone}
|
|
ecFaxNoCarrier = -8068; {Failed to connect to remote fax}
|
|
ecFaxSessionError = -8069; {Fax failed in mid-session}
|
|
ecFaxPageError = -8070; {Fax failed at page end}
|
|
ecFaxGDIPrintError = -8071; {NextBand GDI error in fax print driver}
|
|
ecFaxMixedResolution = -8072; {Multiple resolutions in one session}
|
|
ecFaxConverterInitFail = -8073; {Initialization of fax converter failed}
|
|
ecNoAnswer = -8074; {Remote fax did not answer}
|
|
ecAlreadyMonitored = -8075; {MonitorDir already being used}
|
|
ecFaxMCFNoAnswer = -8076; {Remote disconnected after last page}{!!.06}
|
|
|
|
const
|
|
ecUniAlreadyInstalled = -8080; {Unidrv support files already installed}
|
|
ecUniCannotGetSysDir = -8081; {Cannot determine windows system dir}
|
|
ecUniCannotGetWinDir = -8082; {Cannot determine windows dir}
|
|
ecUniUnknownLayout = -8083; {Cannot determine setup file layout}
|
|
ecUniCannotInstallFile = -8085; {Cannot install Unidrv files to system dir}
|
|
ecRasDDNotInstalled = -8086; {Cannot install RASDD files } {!!.05}
|
|
ecDrvCopyError = -8087; {Error copying printer driver}
|
|
ecCannotAddPrinter = -8088; {32-bit AddPrinter call failed}
|
|
ecDrvBadResources = -8089; {Bad/missing resources in driver}
|
|
ecDrvDriverNotFound = -8090; {Driver file not found}
|
|
ecUniCannotGetPrinterDriverDir
|
|
= -8091; {Cannot determine Win NT printer driver dir}
|
|
ecInstallDriverFailed = -8092; {AddPrinterDriver API failed}
|
|
|
|
{ TApdGSMPhone error codes }
|
|
const
|
|
ecSMSBusy = -8100; {Busy with another command}
|
|
ecSMSTimedOut = -8101; {Timed out, no response back}
|
|
ecSMSTooLong = -8102; {SMS message too long}
|
|
ecSMSUnknownStatus = -8103; {Status unknown}
|
|
ecSMSInvalidNumber = -8138; {Invalid Number or Network out of order} {!!.06}
|
|
ecMEFailure = -8300; {Mobile Equipment Failure}
|
|
ecServiceRes = -8301; {SMS service of ME reserved}
|
|
ecBadOperation = -8302; {Operation not allowed}
|
|
ecUnsupported = -8303; {Operation not supported}
|
|
ecInvalidPDU = -8304; {Invalid PDU mode parameter}
|
|
ecInvalidText = -8305; {Invalid Text mode parameter}
|
|
ecSIMInsert = -8310; {SIM card not inserted}
|
|
ecSIMPin = -8311; {SIM PIN required}
|
|
ecSIMPH = -8312; {PH-SIM PIN required}
|
|
ecSIMFailure = -8313; {SIM failure}
|
|
ecSIMBusy = -8314; {SIM busy}
|
|
ecSIMWrong = -8315; {SIM wrong}
|
|
ecSIMPUK = -8316; {SIM PUK required}
|
|
ecSIMPIN2 = -8317; {SIM PIN2 required}
|
|
ecSIMPUK2 = -8318; {SIM PUK2 required}
|
|
ecMemFail = -8320; {Memory failure}
|
|
ecInvalidMemIndex = -8321; {Invalid memory index}
|
|
ecMemFull = -8322; {Memory full}
|
|
ecSMSCAddUnknown = -8330; {SMS Center Address unknown}
|
|
ecNoNetwork = -8331; {No network service}
|
|
ecNetworkTimeout = -8332; {Network timeout}
|
|
ecCNMAAck = -8340; {No +CNMA acknowledgement expected}
|
|
ecUnknown = -8500; {Unknown error}
|
|
|
|
|
|
const
|
|
ecADWSERROR = 9001;
|
|
ecADWSLOADERROR = 9002;
|
|
ecADWSVERSIONERROR = 9003;
|
|
ecADWSNOTINIT = 9004;
|
|
ecADWSINVPORT = 9005;
|
|
ecADWSCANTCHANGE = 9006;
|
|
ecADWSCANTRESOLVE = 9007;
|
|
|
|
{ All Windows Sockets error constants are biased by 10000 from the "normal" }
|
|
wsaBaseErr = 10000;
|
|
|
|
{ Windows Sockets definitions of regular Microsoft C error constants }
|
|
wsaEIntr = 10004;
|
|
wsaEBadF = 10009;
|
|
wsaEAcces = 10013;
|
|
wsaEFault = 10014;
|
|
wsaEInVal = 10022;
|
|
wsaEMFile = 10024;
|
|
|
|
{ Windows Sockets definitions of regular Berkeley error constants }
|
|
wsaEWouldBlock = 10035;
|
|
wsaEInProgress = 10036;
|
|
wsaEAlReady = 10037;
|
|
wsaENotSock = 10038;
|
|
wsaEDestAddrReq = 10039;
|
|
wsaEMsgSize = 10040;
|
|
wsaEPrototype = 10041;
|
|
wsaENoProtoOpt = 10042;
|
|
wsaEProtoNoSupport = 10043;
|
|
wsaESocktNoSupport = 10044;
|
|
wsaEOpNotSupp = 10045;
|
|
wsaEPfNoSupport = 10046;
|
|
wsaEAfNoSupport = 10047;
|
|
wsaEAddrInUse = 10048;
|
|
wsaEAddrNotAvail = 10049;
|
|
wsaENetDown = 10050;
|
|
wsaENetUnreach = 10051;
|
|
wsaENetReset = 10052;
|
|
wsaEConnAborted = 10053;
|
|
wsaEConnReset = 10054;
|
|
wsaENoBufs = 10055;
|
|
wsaEIsConn = 10056;
|
|
wsaENotConn = 10057;
|
|
wsaEShutDown = 10058;
|
|
wsaETooManyRefs = 10059;
|
|
wsaETimedOut = 10060;
|
|
wsaEConnRefused = 10061;
|
|
wsaELoop = 10062;
|
|
wsaENameTooLong = 10063;
|
|
wsaEHostDown = 10064;
|
|
wsaEHostUnreach = 10065;
|
|
wsaENotEmpty = 10066;
|
|
wsaEProcLim = 10067;
|
|
wsaEUsers = 10068;
|
|
wsaEDQuot = 10069;
|
|
wsaEStale = 10070;
|
|
wsaERemote = 10071;
|
|
wsaEDiscOn = 10101;
|
|
|
|
{ Extended Windows Sockets error constant definitions }
|
|
|
|
wsaSysNotReady = 10091;
|
|
wsaVerNotSupported = 10092;
|
|
wsaNotInitialised = 10093;
|
|
|
|
{ Error return codes from gethostbyname() and gethostbyaddr() (when using the }
|
|
{ resolver). Note that these errors are retrieved via wsaGetLastError() and }
|
|
{ must therefore follow the rules for avoiding clashes with error numbers from }
|
|
{ specific implementations or language run-time systems. For this reason the }
|
|
{ codes are based at 10000+1001. Note also that [wsa]No_Address is defined }
|
|
{ only for compatibility purposes. }
|
|
{ Authoritative Answer: Host not found }
|
|
wsaHost_Not_Found = 11001;
|
|
Host_Not_Found = wsaHost_Not_Found;
|
|
|
|
{ Non-Authoritative: Host not found, or ServerFAIL }
|
|
wsaTry_Again = 11002;
|
|
Try_Again = wsaTry_Again;
|
|
|
|
{ Non recoverable errors, FORMERR, REFUSED, NotIMP }
|
|
wsaNo_Recovery = 11003;
|
|
No_Recovery = wsaNo_Recovery;
|
|
|
|
{ Valid name, no data record of requested type }
|
|
wsaNo_Data = 11004;
|
|
No_Data = wsaNo_Data;
|
|
|
|
{ no address, look for MX record }
|
|
wsaNo_Address = wsaNo_Data;
|
|
No_Address = wsaNo_Address;
|
|
|
|
{ The string resource range 13500 - 13800 is used for TAPI }
|
|
{ status messages, which do not require constants here }
|
|
|
|
const
|
|
{Adjusted TAPI error codes}
|
|
ecAllocated = -13801;
|
|
ecBadDeviceID = -13802;
|
|
ecBearerModeUnavail = -13803;
|
|
ecCallUnavail = -13805;
|
|
ecCompletionOverrun = -13806;
|
|
ecConferenceFull = -13807;
|
|
ecDialBilling = -13808;
|
|
ecDialDialtone = -13809;
|
|
ecDialPrompt = -13810;
|
|
ecDialQuiet = -13811;
|
|
ecIncompatibleApiVersion = -13812;
|
|
ecIncompatibleExtVersion = -13813;
|
|
ecIniFileCorrupt = -13814;
|
|
ecInUse = -13815;
|
|
ecInvalAddress = -13816;
|
|
ecInvalAddressID = -13817;
|
|
ecInvalAddressMode = -13818;
|
|
ecInvalAddressState = -13819;
|
|
ecInvalAppHandle = -13820;
|
|
ecInvalAppName = -13821;
|
|
ecInvalBearerMode = -13822;
|
|
ecInvalCallComplMode = -13823;
|
|
ecInvalCallHandle = -13824;
|
|
ecInvalCallParams = -13825;
|
|
ecInvalCallPrivilege = -13826;
|
|
ecInvalCallSelect = -13827;
|
|
ecInvalCallState = -13828;
|
|
ecInvalCallStatelist = -13829;
|
|
ecInvalCard = -13830;
|
|
ecInvalCompletionID = -13831;
|
|
ecInvalConfCallHandle = -13832;
|
|
ecInvalConsultCallHandle = -13833;
|
|
ecInvalCountryCode = -13834;
|
|
ecInvalDeviceClass = -13835;
|
|
ecInvalDeviceHandle = -13836;
|
|
ecInvalDialParams = -13837;
|
|
ecInvalDigitList = -13838;
|
|
ecInvalDigitMode = -13839;
|
|
ecInvalDigits = -13840;
|
|
ecInvalExtVersion = -13841;
|
|
ecInvalGroupID = -13842;
|
|
ecInvalLineHandle = -13843;
|
|
ecInvalLineState = -13844;
|
|
ecInvalLocation = -13845;
|
|
ecInvalMediaList = -13846;
|
|
ecInvalMediaMode = -13847;
|
|
ecInvalMessageID = -13848;
|
|
ecInvalParam = -13850;
|
|
ecInvalParkID = -13851;
|
|
ecInvalParkMode = -13852;
|
|
ecInvalPointer = -13853;
|
|
ecInvalPrivSelect = -13854;
|
|
ecInvalRate = -13855;
|
|
ecInvalRequestMode = -13856;
|
|
ecInvalTerminalID = -13857;
|
|
ecInvalTerminalMode = -13858;
|
|
ecInvalTimeout = -13859;
|
|
ecInvalTone = -13860;
|
|
ecInvalToneList = -13861;
|
|
ecInvalToneMode = -13862;
|
|
ecInvalTransferMode = -13863;
|
|
ecLineMapperFailed = -13864;
|
|
ecNoConference = -13865;
|
|
ecNoDevice = -13866;
|
|
ecNoDriver = -13867;
|
|
ecNoMem = -13868;
|
|
ecNoRequest = -13869;
|
|
ecNotOwner = -13870;
|
|
ecNotRegistered = -13871;
|
|
ecOperationFailed = -13872;
|
|
ecOperationUnavail = -13873;
|
|
ecRateUnavail = -13874;
|
|
ecResourceUnavail = -13875;
|
|
ecRequestOverrun = -13876;
|
|
ecStructureTooSmall = -13877;
|
|
ecTargetNotFound = -13878;
|
|
ecTargetSelf = -13879;
|
|
ecUninitialized = -13880;
|
|
ecUserUserInfoTooBig = -13881;
|
|
ecReinit = -13882;
|
|
ecAddressBlocked = -13883;
|
|
ecBillingRejected = -13884;
|
|
ecInvalFeature = -13885;
|
|
ecNoMultipleInstance = -13886;
|
|
|
|
const
|
|
{Apro encounters a few of its own TAPI errors, place these error
|
|
codes after the native TAPI error codes, but leave a little bit
|
|
of room for expansion of the TAPI error codes.}
|
|
ecTapiBusy = -13928;
|
|
ecTapiNotSet = -13929;
|
|
ecTapiNoSelect = -13930;
|
|
ecTapiLoadFail = -13931;
|
|
ecTapiGetAddrFail = -13932;
|
|
ecTapiUnexpected = -13934;
|
|
ecTapiVoiceNotSupported = -13935;
|
|
ecTapiWaveFail = -13936;
|
|
ecTapiCIDBlocked = -13937;
|
|
ecTapiCIDOutOfArea = -13938;
|
|
ecTapiWaveFormatError = -13939;
|
|
ecTapiWaveReadError = -13940;
|
|
ecTapiWaveBadFormat = -13941;
|
|
ecTapiTranslateFail = -13942;
|
|
ecTapiWaveDeviceInUse = -13943;
|
|
ecTapiWaveFileExists = -13944;
|
|
ecTapiWaveNoData = -13945;
|
|
|
|
ecVoIPNotSupported = -13950; { TAPI3/H.323 not found }
|
|
ecVoIPCallBusy = -13951; { remote was busy }
|
|
ecVoIPBadAddress = -13952; { destination address bad }
|
|
ecVoIPNoAnswer = -13953; { remote did not answer }
|
|
ecVoIPCancelled = -13954; { cancelled }
|
|
ecVoIPRejected = -13955; { remote rejected the call }
|
|
ecVoIPFailed = -13956; { general failure }
|
|
ecVoIPTapi3NotInstalled = -13957; { ITTapi interface failure } {!!.01}
|
|
ecVoIPH323NotFound = -13958; { H.323 line not found } {!!.01}
|
|
ecVoIPTapi3EventFailure = -13959; { event notify failure } {!!.01}
|
|
|
|
{RAS error codes}
|
|
ecRasLoadFail = -13980;
|
|
|
|
const
|
|
{Convenient character constants (and aliases)}
|
|
cNul = #0;
|
|
cSoh = #1;
|
|
cStx = #2;
|
|
cEtx = #3;
|
|
cEot = #4;
|
|
cEnq = #5;
|
|
cAck = #6;
|
|
cBel = #7;
|
|
cBS = #8;
|
|
cTab = #9;
|
|
cLF = #10;
|
|
cVT = #11;
|
|
cFF = #12;
|
|
cCR = #13;
|
|
cSO = #14;
|
|
cSI = #15;
|
|
cDle = #16;
|
|
cDC1 = #17; cXon = #17;
|
|
cDC2 = #18;
|
|
cDC3 = #19; cXoff = #19;
|
|
cDC4 = #20;
|
|
cNak = #21;
|
|
cSyn = #22;
|
|
cEtb = #23;
|
|
cCan = #24;
|
|
cEM = #25;
|
|
cSub = #26;
|
|
cEsc = #27;
|
|
cFS = #28;
|
|
cGS = #29;
|
|
cRS = #30;
|
|
cUS = #31;
|
|
|
|
type
|
|
{Protocol status information record}
|
|
TProtocolInfo = record
|
|
piProtocolType : Cardinal;
|
|
piBlockErrors : Cardinal;
|
|
piTotalErrors : Cardinal;
|
|
piBlockSize : Cardinal;
|
|
piBlockNum : Cardinal;
|
|
piFileSize : Integer;
|
|
piBytesTransferred : Integer;
|
|
piBytesRemaining : Integer;
|
|
piInitFilePos : Integer;
|
|
piElapsedTicks : Integer;
|
|
piFlags : Integer;
|
|
piBlockCheck : Cardinal;
|
|
piFileName : TPathCharArrayA;
|
|
piError : Integer;
|
|
piStatus : Cardinal;
|
|
end;
|
|
|
|
const
|
|
{Port options}
|
|
poUseEventWord = $04; {Set to use the event word}
|
|
|
|
{ APRO-specific flags used in InitPort}
|
|
ipAssertDTR = $00000001;
|
|
ipAssertRTS = $00000002;
|
|
ipAutoDTR = $00000010;
|
|
ipAutoRTS = $00000020;
|
|
|
|
{Hardware flow control options}
|
|
hfUseDTR = $01; {Use DTR for receive flow control}
|
|
hfUseRTS = $02; {Use RTS for receive flow control}
|
|
hfRequireDSR = $04; {Require DSR before transmitting}
|
|
hfRequireCTS = $08; {Require CTS before transmitting}
|
|
|
|
{Software flow control options}
|
|
sfTransmitFlow = $01; {Honor received Xon/Xoffs}
|
|
sfReceiveFlow = $02; {Send Xon/Xoff as required}
|
|
|
|
{Define bits for TDCB Flags field}
|
|
dcb_Binary = $0001;
|
|
dcb_Parity = $0002;
|
|
dcb_OutxCTSFlow = $0004;
|
|
dcb_OutxDSRFlow = $0008;
|
|
dcb_DTRBit1 = $0010;
|
|
dcb_DTRBit2 = $0020;
|
|
dcb_DsrSensitivity = $0040;
|
|
dcb_TxContinueOnXoff = $0080;
|
|
dcb_OutX = $0100;
|
|
dcb_InX = $0200;
|
|
dcb_ErrorChar = $0400;
|
|
dcb_Null = $0800;
|
|
dcb_RTSBit1 = $1000;
|
|
dcb_RTSBit2 = $2000;
|
|
dcb_AbortOnError = $4000;
|
|
|
|
dcb_DTR_CONTROL_ENABLE = dcb_DTRBit1;
|
|
dcb_DTR_CONTROL_HANDSHAKE = dcb_DTRBit2;
|
|
dcb_RTS_CONTROL_ENABLE = dcb_RTSBit1;
|
|
dcb_RTS_CONTROL_HANDSHAKE = dcb_RTSBit2;
|
|
dcb_RTS_CONTROL_TOGGLE = (dcb_RTSBit1 + dcb_RTSBit2);
|
|
|
|
{For reporting flow states, note: no receive hardware flow status is provided}
|
|
fsOff = 1; {No flow control is in use}
|
|
fsOn = 2; {Flow control is but not transmit blocked}
|
|
fsDsrHold = 3; {Flow control is on and transmit blocked by low DSR}
|
|
fsCtsHold = 4; {Flow control is on and transmit blocked by low CTS}
|
|
fsDcdHold = 5; {Flow control is on and transmit blocked by low DCD}
|
|
fsXOutHold = 6; {Flow control is on and transmit blocked by Xoff}
|
|
fsXInHold = 7; {Flow control is on and receive blocked by Xoff}
|
|
fsXBothHold= 8; {Flow control is on and both are blocked by Xoff}
|
|
|
|
const
|
|
{Emulator commands}
|
|
eNone = 0; {No command, ignore this char}
|
|
eChar = 1; {No command, process the char}
|
|
eGotoXY = 2; {X} {Absolute goto cursor position call}
|
|
eUp = 3; {X} {Cursor up}
|
|
eDown = 4; {X} {Cursor down}
|
|
eRight = 5; {X} {Cursor right}
|
|
eLeft = 6; {X} {Cursor left}
|
|
eClearBelow = 7; {R} {Clear screen below cursor}
|
|
eClearAbove = 8; {R} {Clear screen above cursor}
|
|
eClearScreen = 9; {R} {Clear entire screen}
|
|
eClearEndofLine = 10;{R} {Clear from cursor to end of line}
|
|
eClearStartOfLine= 11;{R} {Clear from cursor to the start of line}
|
|
eClearLine = 12;{R} {Clear entire line that cursor is on}
|
|
eSetMode = 13;{X} {Set video mode}
|
|
eSetBackground = 14; {Set background attribute}
|
|
eSetForeground = 15; {Set foreground attribute}
|
|
eSetAttribute = 16;{X} {Set video attribute (foreground and background)}
|
|
eSaveCursorPos = 17; {Save cursor position}
|
|
eRestoreCursorPos= 18; {Restore cursor position}
|
|
eDeviceStatusReport = 19;{X}{Report device status or cursor position}
|
|
eString = 20; {Pascal style string}
|
|
eHT = 21; {Horizontal Tab Character}
|
|
eError = 255; {indicates a parser error}
|
|
|
|
eAPC { } = 30; {Application programming command}
|
|
eCBT {X} = 31; {Cursor backward tabulation}
|
|
eCCH { } = 32; {Cancel character}
|
|
eCHA {X} = 33; {Cursor horizontal absolute}
|
|
eCHT {X} = 34; {Cursor horizontal tabulation}
|
|
eCNL {X} = 35; {Cursor next line}
|
|
eCPL {X} = 36; {Cursor preceding line}
|
|
eCPR {X} = 37; {Cursor position report}
|
|
eCRM {.} = 38; {Control representation mode}
|
|
eCTC {X} = 39; {Cursor tabulation control}
|
|
eCUB {X} = eLeft; {Cursor backward}
|
|
eCUD {X} = eDown; {Cursor down}
|
|
eCUF {X} = eRight; {Cursor forward}
|
|
eCUP {X} = eGotoXY; {Cursor position}
|
|
eCUU {X} = eUp; {Cursor up}
|
|
eCVT {X} = 40; {Cursor vertical tabulation}
|
|
eDA {X} = 41; {Device attributes}
|
|
eDAQ { } = 42; {Define area qualification}
|
|
eDCH {X} = 43; {Delete character}
|
|
eDCS { } = 44; {Device control string}
|
|
eDL {X} = 45; {Delete line}
|
|
eDMI { } = 46; {Disable manual input}
|
|
eDSR {X} = eDeviceStatusReport;{Device status report}
|
|
eEA { } = 47; {Erase in area}
|
|
eEBM { } = 48; {Editing boundry mode}
|
|
eECH {X} = 49; {Erase character}
|
|
eED {X} = 50; {Erase in Display}
|
|
eEF { } = 51; {Erase in field}
|
|
eEL {X} = 52; {Erase in line}
|
|
eEMI { } = 53; {Enable manual input}
|
|
eEPA { } = 54; {End of protected mode}
|
|
eERM { } = 55; {Erasure mode}
|
|
eESA { } = 56; {End of selected area}
|
|
eFEAM { } = 57; {Format effector action mode}
|
|
eFETM { } = 58; {Format effector transfer mode}
|
|
eFNT { } = 59; {Font selection}
|
|
eGATM { } = 60; {Guarded area transfer mode}
|
|
eGSM { } = 61; {Graphics size modification}
|
|
eGSS { } = 62; {Graphics size selection}
|
|
eHEM { } = 63; {Horizontal editing mode}
|
|
eHPA {X} = eCHA; {Horizontal position absolute}
|
|
eHPR {X} = eCUF; {Horizontal position relative}
|
|
eHTJ {X} = 64; {Horizontal tab with justification}
|
|
eHTS {X} = 65; {Horizontal tabulation set}
|
|
eHVP {X} = eCUP; {Horizontal and vertical position}
|
|
eICH {X} = 66; {Insert character}
|
|
eIL {X} = 67; {Insert line}
|
|
eIND {X} = eCUD; {Index}
|
|
eINT { } = 68; {Interrupt}
|
|
eIRM {.} = 69; {Inseration-Replacement mode}
|
|
eJFY { } = 70; {Justify}
|
|
eKAM {.} = 71; {Keyboard action mode}
|
|
eLNM {.} = 72; {Line feed new line mode}
|
|
eMATM { } = 73; {Multiple area transfer mode}
|
|
eMC {.} = 74; {Media copy}
|
|
eMW {.} = 75; {Message waiting}
|
|
eNEL {X} = 76; {Next line}
|
|
eNP {.} = 77; {Next page}
|
|
eOSC { } = 78; {Operating system command}
|
|
ePLD { } = 79; {Partial line down}
|
|
ePLU { } = 80; {Partial line up}
|
|
ePM { } = 81; {Privacy message}
|
|
ePP {.} = 82; {Preceding page}
|
|
ePU1 { } = 83; {Private use 1}
|
|
ePU2 { } = 84; {Private use 2}
|
|
ePUM { } = 85; {Positioning unit mode}
|
|
eQUAD { } = 86; {Quad}
|
|
eREP { } = 87; {Repeat}
|
|
eRI {X} = 88; {Reverse index}
|
|
eRIS {.} = 89; {Reset to initial state}
|
|
eRM {.} = 90; {Reset mode}
|
|
eSATM { } = 91; {Selected area transfer mode}
|
|
eSD { } = 92; {Scroll down}
|
|
eSEM { } = 93; {selected editing extent mode}
|
|
eSGR {X} = eSetAttribute;{Select graphics rendition}
|
|
eSL { } = 94; {Scroll left}
|
|
eSM {.} = eSetMode;{Set Mode}
|
|
eSPA { } = 95; {Start of protected area}
|
|
eSPI { } = 96; {Spacing increment}
|
|
eSR { } = 97; {Scroll right}
|
|
eSRM { } = 98; {Send-Receive mode}
|
|
eSRTM { } = 99; {Status report transfer mode}
|
|
eSS2 { } = 100; {Single shift 2}
|
|
eSS3 { } = 101; {Single shift 3}
|
|
eSSA { } = 102; {Start of selected area}
|
|
eST { } = 103; {String terminator}
|
|
eSTS { } = 104; {Set transmit state}
|
|
eSU { } = 105; {Scroll up}
|
|
eTBC {X} = 106; {Tabulation clear}
|
|
eTSM { } = 107; {Tabulation stop mode}
|
|
eTSS { } = 108; {Thin space specification}
|
|
eTTM { } = 109; {Transfer termination mode}
|
|
eVEM { } = 110; {Vertical editing mode}
|
|
eVPA {X} = 111; {Vertical position absolute}
|
|
eVPR {X} = eCUD; {Vertical position relative}
|
|
eVTS {X} = 112; {vertical tabulation set}
|
|
eDECSTBM = 113; {dec private-set Top/Bottom margin}
|
|
|
|
eENQ {X} = 114; {enquiry request}
|
|
eBEL {X} = 115; {sound bell}
|
|
eBS {X} = 116; {backspace}
|
|
eLF {X} = 117; {line feed command}
|
|
eCR {X} = 118; {carriage return}
|
|
eSO {X} = 119; {invoke G1 charset}
|
|
eSI {X} = 120; {invoke G0 charset}
|
|
eIND2 {X} = 121; {corrected eIND (<> eCUD, eDown) new term only}
|
|
eDECALN = 122; {DEC PRIVATE-screen alignment display}
|
|
eDECDHL = 123; {DEC PRIVATE-Double height line}
|
|
eDECDWL = 124; {DEC PRIVATE-Double width line}
|
|
eDECLL = 125; {DEC PRIVATE-load LEDs}
|
|
eDECREQTPARM = 126; {DEC PRIVATE-request terminal parameters}
|
|
eDECSWL = 127; {DEC PRIVATE-single width line}
|
|
eDECTST = 128; {DEC PRIVATE-Invoke confidence test}
|
|
eDECSCS = 129; {DEC PRIVATE-select charset}
|
|
|
|
{Extended attributes}
|
|
eattrBlink = $01;
|
|
eattrInverse = $02;
|
|
eattrIntense = $04;
|
|
eattrInvisible = $08;
|
|
eattrUnderline = $10;
|
|
|
|
{ANSI color constants}
|
|
emBlack = 0;
|
|
emRed = 1;
|
|
emGreen = 2;
|
|
emYellow = 3;
|
|
emBlue = 4;
|
|
emMagenta = 5;
|
|
emCyan = 6;
|
|
emWhite = 7;
|
|
emBlackBold = 8;
|
|
emRedBold = 9;
|
|
emGreenBold = 10;
|
|
emYellowBold = 11;
|
|
emBlueBold = 12;
|
|
emMagentaBold = 13;
|
|
emCyanBold = 14;
|
|
emWhiteBold = 15;
|
|
|
|
{AnsiEmulator option flags}
|
|
teMapVT100 = $0001;
|
|
|
|
{Misc}
|
|
MaxParams = 5; {Maximum parameters for our interpreter}
|
|
MaxQueue = 20; {Maximum characters in queue}
|
|
MaxOther = 11; {Maximum other data}
|
|
MaxParamLength = 5; {Maximum parameter length for interpreter}
|
|
KeyMappingLen = 20; {Maximum length of a keymapping}
|
|
|
|
type
|
|
{AnsiEmulator's parser states}
|
|
TAnsiParser = (GotNone, GotEscape, GotBracket, GotSemiColon, GotParam,
|
|
GotCommand, GotControlSeqIntro, GotLeftBrace, GotRightBrace,
|
|
GotSpace, GotQuestionMark, GotQuestionParam);
|
|
|
|
{Array used for internal queue}
|
|
TApQueue = Array[1..MaxQueue] of AnsiChar; // SWB
|
|
|
|
{Emulator for PC ANSI codes}
|
|
PAnsiEmulator = ^TAnsiEmulator;
|
|
TAnsiEmulator = record
|
|
emuType : Cardinal; { Emulator Type }
|
|
emuFlags : Cardinal;
|
|
emuFirst : Bool; {True if first time thru}
|
|
emuAttr : Byte;
|
|
emuIndex : Cardinal; {Index into rcvd byte array}
|
|
emuParamIndex : Cardinal; {Parameter index}
|
|
emuQueue : TApQueue; {Queue of recvd bytes} // SWB
|
|
emuParamStr : array[1..MaxParams] of string[MaxParamLength];
|
|
emuParamInt : array[1..MaxParams] of Integer;
|
|
emuParserState : TAnsiParser; {Current state}
|
|
emuOther : Pointer;
|
|
end;
|
|
|
|
const
|
|
{Terminal window Cardinal}
|
|
gwl_Terminal = 0;
|
|
|
|
{Terminal options}
|
|
tws_WantTab = $0001; {Process tabs internally}
|
|
tws_IntHeight = $0002; {Integral height}
|
|
tws_IntWidth = $0004; {Integral width}
|
|
tws_AutoHScroll = $0008; {Add/remove horiz scroll automatically}
|
|
tws_AutoVScroll = $0010; {Add/remove vert scroll automatically}
|
|
|
|
type
|
|
{For general typecasting}
|
|
LH = record
|
|
L,H : Word;
|
|
end;
|
|
|
|
{IniDBase (deprecated) consts and types}
|
|
const
|
|
MaxDBRecs = 999; {Maximum number of database records}
|
|
MaxNameLen = 21; {Maximum length of a profile string key}
|
|
MaxIndexLen = 31; {Maximum length of an index string}
|
|
NonValue = '#'; {Value of DB fields SPECIFICALLY left blank}
|
|
dbIndex = 'Index'; {Item index section heading}
|
|
dbDefaults = 'Defaults'; {Default value section heading}
|
|
dbNumEntries = '_Entries'; {Number of entries key name}
|
|
dbBogus = 'None'; {Bogus key name for creating sections}
|
|
|
|
type
|
|
PIniDatabaseKey = ^TIniDatabaseKey;
|
|
TIniDatabaseKey = record
|
|
KeyName : PAnsiChar;
|
|
DataSize : Cardinal;
|
|
StrType : Bool;
|
|
Index : Bool;
|
|
Next : PIniDatabaseKey;
|
|
end;
|
|
|
|
PIniDatabase = ^TIniDatabase;
|
|
TIniDatabase = record
|
|
FName : PAnsiChar;
|
|
DictionaryHead : PIniDatabaseKey;
|
|
DictionaryTail : PIniDatabaseKey;
|
|
NumRecords : Integer;
|
|
RecordSize : Cardinal;
|
|
DefaultRecord : Pointer;
|
|
Prepared : Bool;
|
|
end;
|
|
|
|
const
|
|
ApdMaxTags = 5; {Maximum number of err corr or data comp tags}
|
|
ApdTagSepChar = ','; {Character that separates tags in a profile string}
|
|
|
|
const
|
|
ApdModemNameLen = 31; {Length of a modem name string}
|
|
ApdCmdLen = 41; {Maximum length of a modem command}
|
|
ApdRspLen = 21; {Maximum length of a modem response}
|
|
ApdTagLen = 21; {Maximum length of a tag string}
|
|
ApdTagProfLen = 105; {Maximum length of a tag profile string}
|
|
ApdBoolLen = 5; {Maximum length of a boolean string}
|
|
ApdBaudLen = 7; {Maximum length of a baud rate string}
|
|
ApdConfigLen = 255; {Maximum length of a configuration string}
|
|
|
|
type
|
|
{where these same variables are declared as Strings.}
|
|
TModemNameZ = array[0..ApdModemNameLen] of AnsiChar; //SZ: must probably be Ansi
|
|
TCmdStringZ = array[0..ApdCmdLen] of AnsiChar;
|
|
TRspStringZ = array[0..ApdRspLen] of AnsiChar;
|
|
TTagStringZ = array[0..ApdTagLen] of AnsiChar;
|
|
TTagProfStringZ = array[0..ApdTagProfLen] of AnsiChar;
|
|
TConfigStringZ = array[0..ApdConfigLen] of AnsiChar;
|
|
TBoolStrZ = array[0..ApdBoolLen] of AnsiChar;
|
|
TBaudStrZ = array[0..ApdBaudLen] of AnsiChar;
|
|
|
|
TTagArrayZ = array[1..ApdMaxTags] of TTagStringZ;
|
|
|
|
PModemBaseData = ^TModemBaseData;
|
|
TModemBaseData = record
|
|
Name : TModemNameZ;
|
|
InitCmd : TCmdStringZ;
|
|
DialCmd : TCmdStringZ;
|
|
DialTerm : TCmdStringZ;
|
|
DialCancel : TCmdStringZ;
|
|
HangupCmd : TCmdStringZ;
|
|
ConfigCmd : TConfigStringZ;
|
|
AnswerCmd : TCmdStringZ;
|
|
OkMsg : TRspStringZ;
|
|
ConnectMsg : TRspStringZ;
|
|
BusyMsg : TRspStringZ;
|
|
VoiceMsg : TRspStringZ;
|
|
NoCarrierMsg : TRspStringZ;
|
|
NoDialToneMsg : TRspStringZ;
|
|
ErrorMsg : TRspStringZ;
|
|
RingMsg : TRspStringZ;
|
|
end;
|
|
|
|
PModemData = ^TModemData;
|
|
TModemData = record
|
|
Data : TModemBaseData;
|
|
NumErrors : Cardinal;
|
|
Errors : TTagArrayZ;
|
|
NumComps : Cardinal;
|
|
Compression : TTagArrayZ;
|
|
LockDTE : Bool;
|
|
DefBaud : Integer;
|
|
end;
|
|
|
|
PModemXFer = ^TModemXFer;
|
|
TModemXFer = record
|
|
Data : TModemBaseData;
|
|
Errors : TTagProfStringZ;
|
|
Compress : TTagProfStringZ;
|
|
LockDTE : TBoolStrZ;
|
|
DefBaud : TBaudStrZ;
|
|
end;
|
|
|
|
PModemDatabase = ^TModemDatabase;
|
|
TModemDatabase = record
|
|
DB : PIniDatabase;
|
|
end;
|
|
|
|
|
|
const
|
|
{keyboard shift state masks}
|
|
ksControl = $02;
|
|
ksAlt = $04;
|
|
ksShift = $08;
|
|
|
|
{keyboard toggle state masks}
|
|
tsCapital = $02;
|
|
tsNumlock = $04;
|
|
tsScroll = $08;
|
|
|
|
{keyboard INI file constants}
|
|
ApdKeyMapNameLen = 30; {Length of a KeyMap name string}
|
|
ApdMaxKeyMaps = 100; {Maximum possible key mapping per type}
|
|
|
|
ApdKeyIndexName = 'EMULATOR';
|
|
ApdKeyIndexMaxLen = 120;
|
|
|
|
type
|
|
TKeyMapName = array[0..ApdKeyMapNameLen] of AnsiChar;
|
|
TKeyMapping = array[0..KeyMappingLen] of Ansichar;
|
|
TKeyMappingStr = string[KeyMappingLen];
|
|
|
|
|
|
PKeyMapXFerRec = ^TKeyMapXFerRec;
|
|
TKeyMapXFerRec = record
|
|
Name : TKeyMapName;
|
|
Keys : array[1..ApdMaxKeyMaps] of TKeyMapping;
|
|
end;
|
|
|
|
PVKeyMapRec = ^TVKeyMapRec;
|
|
TVKEyMapRec = record
|
|
KeyCode : Cardinal;
|
|
ShiftState: Cardinal;
|
|
Mapping : TKeyMappingStr;
|
|
end;
|
|
|
|
PKeyEmulator = ^TKeyEmulator;
|
|
TKeyEmulator = record
|
|
kbKeyFileName : PChar; { current file name }
|
|
kbKeyName : TKeyMapName; { current key index name }
|
|
kbProcessAll : Bool;
|
|
kbProcessExt : Bool;
|
|
kbKeyNameList : array[0..ApdKeyIndexMaxLen] of Ansichar;
|
|
kbKeyMap : array[1..ApdMaxKeyMaps] of TVKeyMapRec;
|
|
kbKeyDataBase : PIniDataBase; { pointer to the INI data base file }
|
|
end;
|
|
|
|
const
|
|
{---- Option codes for protocols ----}
|
|
apIncludeDirectory = $0001; {Set to include directory in file names}
|
|
apHonorDirectory = $0002; {Set to honor directory in file names}
|
|
apRTSLowForWrite = $0004; {Set to lower RTS during disk writes}
|
|
apAbortNoCarrier = $0008; {Set to abort protocol on DCD loss}
|
|
apKermitLongPackets = $0010; {Set to support long packets}
|
|
apKermitSWC = $0020; {Set to support SWC}
|
|
apZmodem8K = $0040; {Set to support 8K blocks}
|
|
apBP2KTransmit = $0080; {Set to support 2K transmit blocks}
|
|
apAsciiSuppressCtrlZ = $0100; {Set to stop transmitting on ^Z}
|
|
|
|
{---- Default options for protocols ----}
|
|
DefProtocolOptions = 0;
|
|
BadProtocolOptions = apKermitLongPackets+apKermitSWC+apZmodem8K;
|
|
|
|
{Block check codes}
|
|
bcNone = 0; {No block checking}
|
|
bcChecksum1 = 1; {Basic checksum}
|
|
bcChecksum2 = 2; {Two byte checksum}
|
|
bcCrc16 = 3; {16 bit Crc}
|
|
bcCrc32 = 4; {32 bit Crc}
|
|
bcCrcK = 5; {Kermit style Crc}
|
|
|
|
{Convenient blockcheck string constants}
|
|
bcsNone = 'No check';
|
|
bcsChecksum1 = 'Checksum';
|
|
bcsChecksum2 = 'Checksum2';
|
|
bcsCrc16 = 'Crc16';
|
|
bcsCrc32 = 'Crc32';
|
|
bcsCrck = 'CrcKermit';
|
|
|
|
{Constants for supported protocol types}
|
|
NoProtocol = 0;
|
|
Xmodem = 1;
|
|
XmodemCRC = 2;
|
|
Xmodem1K = 3;
|
|
Xmodem1KG = 4;
|
|
Ymodem = 5;
|
|
YmodemG = 6;
|
|
Zmodem = 7;
|
|
Kermit = 8;
|
|
Ascii = 9;
|
|
BPlus = 10;
|
|
|
|
{Zmodem attention string length}
|
|
MaxAttentionLen = 32;
|
|
|
|
{Zmodem file management options}
|
|
zfWriteNewerLonger = 1; {Transfer if new, newer or longer}
|
|
zfWriteCrc = 2; {Not supported, same as WriteNewer}
|
|
zfWriteAppend = 3; {Transfer if new, append if exists}
|
|
zfWriteClobber = 4; {Transfer regardless}
|
|
zfWriteNewer = 5; {Transfer if new or newer}
|
|
zfWriteDifferent = 6; {Transfer if new or diff dates/lens}
|
|
zfWriteProtect = 7; {Transfer only if new}
|
|
|
|
{Convenient protocol string constants}
|
|
ProtocolString : array[NoProtocol..BPlus] of array[0..9] of AnsiChar= (
|
|
'None', 'Xmodem', 'XmodemCRC', 'Xmodem1K', 'Xmodem1KG',
|
|
'Ymodem', 'YmodemG', 'Zmodem', 'Kermit', 'Ascii', 'B+');
|
|
|
|
type
|
|
{For holding lists of files to transmit}
|
|
PFileList = ^TFileList;
|
|
TFileList = array[0..65535-1] of Char;
|
|
|
|
{Fax conversion}
|
|
|
|
const
|
|
rw1728 = 1; {standard width}
|
|
rw2048 = 2; {extra wide}
|
|
|
|
{Fax pixel widths}
|
|
StandardWidth = 1728; {Standard width in pixels}
|
|
WideWidth = 2048; {Allowed higher resolution}
|
|
|
|
{Option flags for FAX page header}
|
|
ffHighRes = $0001; {Image stored in high-res mode}
|
|
ffHighWidth = $0002; {Image uses option high-width mode}
|
|
ffLengthWords = $0004; {Set if raster lines include length Cardinal}
|
|
|
|
{Options for fax conversion}
|
|
fcDoubleWidth = $0001; {Double the horizontal width in std res}
|
|
fcHalfHeight = $0002; {Halve the vertical height in std res}
|
|
fcCenterImage = $0004; {Center graphics images horizontally}
|
|
fcYield = $0008; {Have the converter yield while converting}
|
|
fcYieldOften = $0010; {Increases the number of yields}
|
|
|
|
{Flags passed to status function}
|
|
csStarting = $0001;
|
|
csEnding = $0002;
|
|
|
|
{Font handles, same value as bytes-per-char}
|
|
SmallFont = 16;
|
|
StandardFont = 48;
|
|
|
|
{Maximum number of tree records}
|
|
MaxTreeRec = 306;
|
|
|
|
{Max size of decompress buffer}
|
|
MaxData = 4096;
|
|
|
|
{Text conversion limits}
|
|
MaxLineLen = 144;
|
|
|
|
{encoding/decoding table limits}
|
|
MaxCodeTable = 63;
|
|
MaxMUCodeTable = 39;
|
|
|
|
{default extensions}
|
|
DefTextExt = 'TXT';
|
|
DefTiffExt = 'TIF';
|
|
DefPcxExt = 'PCX';
|
|
DefDcxExt = 'DCX';
|
|
DefBmpExt = 'BMP';
|
|
DefApfExt = 'APF';
|
|
|
|
type
|
|
{Compression code tables}
|
|
TCodeRec = record
|
|
Code : Word;
|
|
Sig : Word;
|
|
end;
|
|
|
|
TTermCodeArray = array[0..MaxCodeTable] of TCodeRec;
|
|
TMakeUpCodeArray = array[0..MaxMUCodeTable] of TCodeRec;
|
|
|
|
PBufferedOutputFile = ^TBufferedOutputFile;
|
|
TBufferedOutputFile = record
|
|
BufPos : Word;
|
|
Buffer : PByteArray;
|
|
OutFile : File;
|
|
end;
|
|
|
|
{For storing station IDs}
|
|
Str20 = string[20];
|
|
|
|
{Stores information about our fonts}
|
|
TFontRecord = record
|
|
Bytes : Byte; {# of bytes per char in font}
|
|
PWidth : Byte; {width of font in pixels}
|
|
Width : Byte; {width of font in bytes (e.g. 16-pixel-wide = 2)}
|
|
Height : Byte; {height of font in raster lines}
|
|
end;
|
|
|
|
{Fax file signature array}
|
|
TSigArray = Array[0..5] of AnsiChar;
|
|
|
|
const
|
|
{Default fax file signature, first 6 chars in an APF}
|
|
DefAPFSig : TSigArray = 'APF10'#26;
|
|
|
|
type
|
|
{APRO fax file header record}
|
|
TFaxHeaderRec = packed record
|
|
Signature : TSigArray; {APRO FAX signature}
|
|
FDateTime : Integer; {Date and time in DOS format}
|
|
SenderID : Str20; {Station ID of sender}
|
|
Filler : Byte; {Alignment byte, unused}
|
|
PageCount : Word; {Number of pages in this file}
|
|
PageOfs : Integer; {Offset in file of first page}
|
|
Padding : Array[39..64] of Byte; {Expansion room}
|
|
end;
|
|
|
|
{APRO fax page header record}
|
|
TPageHeaderRec = packed record
|
|
ImgLength : Integer; {Bytes of image data in this page}
|
|
ImgFlags : Word; {Image flags for width, res, etc}
|
|
Padding : Array[7..16] of Byte; {Expansion room}
|
|
end;
|
|
|
|
{APRO fax server job header}
|
|
TFaxJobHeaderRec = packed record
|
|
ID : Integer; {APRO fax job signature}
|
|
Status : Byte; {0=none sent, 1=some sent, 2=all sent, 3=paused}
|
|
JobName : Str20; {Friendly name of fax job}
|
|
Sender : String[40]; {Name of sender (same as HeaderSender)}
|
|
SchedDT : TDateTime; {TDateTime the first job should be sent}
|
|
NumJobs : Byte; {Number of FaxJobInfoRecs for this job}
|
|
NextJob : Byte; {The index of the next FaxJobInfo to send}
|
|
CoverOfs : Integer; {Offset in file of text CoverFile data}
|
|
FaxHdrOfs: Integer; {Offset in file of TFaxHeaderRec}
|
|
Padding : Array[86..128] of Byte; {Expansion room}
|
|
end;
|
|
|
|
{APRO fax server job recipient record }
|
|
TFaxRecipientRec = packed record
|
|
Status : Byte; {0=not sent, 1=sending, 2=sent, 3=paused}
|
|
JobID : Byte; {Unique ID for this job}
|
|
SchedDT : TDateTime; {TDateTime this job should be sent}
|
|
AttemptNum : Byte; {Retry number for this recipient}
|
|
LastResult : Word; {Last ErrorCode for this fax}
|
|
PhoneNumber : String[50]; {Phone number to dial for this job}
|
|
HeaderLine : String[100]; {Header line}
|
|
HeaderRecipient: String[30]; {Recipient's name}
|
|
HeaderTitle : String[30]; {Title of fax}
|
|
Padding : Array[228..256] of Byte;{Expansion room}
|
|
end;
|
|
|
|
{Pcx header}
|
|
TPcxPalArray = Array[0..47] of Byte;
|
|
TPcxHeaderRec = packed record
|
|
Mfgr : Byte;
|
|
Ver : Byte;
|
|
Encoding : Byte;
|
|
BitsPixel : Byte;
|
|
XMin : Word;
|
|
YMin : Word;
|
|
XMax : Word;
|
|
YMax : Word;
|
|
HRes : Word;
|
|
VRes : Word;
|
|
Palette : TPcxPalArray;
|
|
Reserved : Byte;
|
|
Planes : Byte;
|
|
BytesLine : Word;
|
|
PalType : Word;
|
|
Filler : Array[1..58] of Byte; {pad to 128 bytes}
|
|
end;
|
|
|
|
TDcxOfsArray = array[1..1024] of Integer;
|
|
|
|
PDcxHeaderRec = ^TDcxHeaderRec;
|
|
TDcxHeaderRec = packed record
|
|
ID : Integer;
|
|
Offsets : TDcxOfsArray;
|
|
end;
|
|
|
|
TTreeRec = record
|
|
Next0 : Integer;
|
|
Next1 : Integer;
|
|
end;
|
|
TTreeArray = array[0..MaxTreeRec] of TTreeRec;
|
|
PTreeArray = ^TTreeArray;
|
|
|
|
{$IFNDEF DrvInst}
|
|
PAbsFaxCvt = ^TAbsFaxCvt;
|
|
|
|
{callback function to open a converter input file}
|
|
TOpenFileCallback = function(Cvt : PAbsFaxCvt; FileName : string) : Integer;
|
|
|
|
{callback function to close a converter input file}
|
|
TCloseFileCallback = procedure(Cvt : PAbsFaxCvt);
|
|
|
|
{callback function converters use to get input raster}
|
|
TGetLineCallback = function(Cvt : PAbsFaxCvt; var Data; var Len : Integer;
|
|
var EndOfPage, MorePages : Bool) : Integer;
|
|
|
|
{callback function converters use to output data}
|
|
TPutLineCallback = function(Cvt : PAbsFaxCvt; var Data; Len : Integer;
|
|
EndOfPage, MorePages : Bool) : Integer;
|
|
|
|
|
|
{callback function for status information}
|
|
TCvtStatusCallback = function(Cvt : PAbsFaxCvt; StatFlags : Word;
|
|
BytesRead, BytesToRead : Integer) : Bool;
|
|
|
|
{base converter data}
|
|
TAbsFaxCvt = record
|
|
UseHighRes : Bool; {TRUE if for high-res mode}
|
|
DoubleWidth : Bool; {TRUE do double each pixel}
|
|
HalfHeight : Bool; {TRUE to discard each raster line}
|
|
Flags : Cardinal; {Options flags}
|
|
ByteOfs : Cardinal; {Byte offset in buffer}
|
|
BitOfs : Cardinal; {Bit offset in buffer}
|
|
ResWidth : Cardinal; {Width of current resolution in pels}
|
|
LeftMargin : Cardinal; {Left margin in pels}
|
|
TopMargin : Cardinal; {Top margin in pels}
|
|
CurrPage : Cardinal; {Current page being processed}
|
|
CurrLine : Cardinal; {Number of text/raster lines cvted}
|
|
LastPage : Cardinal; {Last page number used in file cvt}
|
|
CurPagePos : Integer; {file offset of current page}
|
|
CenterOfs : Cardinal; {Offset of center of bitmap}
|
|
UserData : Pointer; {Data needed by higher level cvters}
|
|
OtherData : Pointer; {Other, miscellaneous data}
|
|
BytesRead : Integer;
|
|
BytesToRead : Integer;
|
|
DataLine : PByteArray; {Buffered line of compressed data}
|
|
TmpBuffer : PByteArray; {Temp compression buffer}
|
|
GetLine : TGetLineCallback; {Callback function to get a raster line}
|
|
OpenCall : TOpenFileCallback; {To open the input file, if any}
|
|
CloseCall : TCloseFileCallback; {To close the input file, if any}
|
|
StatusFunc : TCvtStatusCallback; {Callback for status display}
|
|
StatusWnd : HWnd; {Handle of window receiving status msgs}
|
|
DefExt : string; // array[0..3] of AnsiChar;
|
|
InFileName : string; // array[0..255] of AnsiChar;
|
|
OutFileName : string; // array[0..255] of AnsiChar;
|
|
StationID : AnsiString; //array[0..20] of AnsiChar;
|
|
MainHeader : TFaxHeaderRec; {main header of fax output file}
|
|
PageHeader : TPageHeaderRec; {header for current output page}
|
|
OutFile : PBufferedOutputFile;{Output file}
|
|
PadPage : Bool; {True to pad text conversion to full page}{!!.04}
|
|
{$IFNDEF PrnDrv}
|
|
InBitmap : Graphics.TBitmap;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
|
|
type
|
|
{ moved from AdWUtil } {!!.06}
|
|
SunB = packed record {!!.06}
|
|
s_b1, s_b2, s_b3, s_b4 : AnsiChar; {!!.06}
|
|
end; {!!.06}
|
|
{ moved from AdWUtil } {!!.06}
|
|
SunW = packed record {!!.06}
|
|
s_w1, s_w2 : Word; {!!.06}
|
|
end; {!!.06}
|
|
|
|
{ moved from AdWnPort and AdWUtil } {!!.06}
|
|
PInAddr = ^TInAddr; {!!.06}
|
|
TInAddr = packed record {!!.06}
|
|
case Integer of {!!.06}
|
|
0 : (S_un_b : SunB); {!!.06}
|
|
1 : (S_un_w : SunW); {!!.06}
|
|
2 : (S_addr : Integer); {!!.06}
|
|
end; {!!.06}
|
|
|
|
{ XML support }
|
|
const
|
|
{The following constants are the tokens needed to parse an XML
|
|
document. The tokens are stored in UCS-4 format to reduce the
|
|
number of conversions needed by the filter.}
|
|
Xpc_BracketAngleLeft : array[0..0] of Integer = (60); {<}
|
|
Xpc_BracketAngleRight : array[0..0] of Integer = (62); {>}
|
|
Xpc_BracketSquareLeft : array[0..0] of Integer = (91); {[}
|
|
Xpc_BracketSquareRight : array[0..0] of Integer = (93); {]}
|
|
Xpc_CDATAStart :
|
|
array[0..5] of Integer = (67, 68, 65, 84, 65, 91); {CDATA[}
|
|
Xpc_CharacterRef : array[0..0] of Integer = (35); {#}
|
|
Xpc_CharacterRefHex : array[0..0] of Integer = (120); {x}
|
|
Xpc_CommentEnd : array[0..2] of Integer = (45, 45, 62); {-->}
|
|
Xpc_CommentStart : array[0..3] of Integer = (60, 33, 45, 45); {<!--}
|
|
Xpc_ConditionalEnd : array[0..2] of Integer = (93, 93, 62); {]]>}
|
|
Xpc_ConditionalIgnore :
|
|
array[0..5] of Integer = (73, 71, 78, 79, 82, 69); {IGNORE}
|
|
Xpc_ConditionalInclude :
|
|
array[0..6] of Integer = (73, 78, 67, 76, 85, 68, 69); {INCLUDE}
|
|
Xpc_ConditionalStart :
|
|
array[0..2] of Integer = (60, 33, 91); {<![}
|
|
Xpc_Dash : array[0..0] of Integer = (45); {-}
|
|
Xpc_DTDAttFixed :
|
|
array[0..4] of Integer = (70, 73, 88, 69, 68); {FIXED}
|
|
Xpc_DTDAttImplied :
|
|
array[0..6] of Integer = (73, 77, 80, 76, 73, 69, 68); {IMPLIED}
|
|
Xpc_DTDAttlist :
|
|
array[0..8] of Integer =
|
|
(60, 33, 65, 84, 84, 76, 73, 83, 84); {<!ATTLIST}
|
|
Xpc_DTDAttRequired :
|
|
array[0..7] of Integer =
|
|
(82, 69, 81, 85, 73, 82, 69, 68); {REQUIRED}
|
|
Xpc_DTDDocType :
|
|
array[0..8] of Integer =
|
|
(60, 33, 68, 79, 67, 84, 89, 80, 69); {<!DOCTYPE}
|
|
Xpc_DTDElement :
|
|
array[0..8] of Integer =
|
|
(60, 33, 69, 76, 69, 77, 69, 78, 84); {<!ELEMENT}
|
|
Xpc_DTDElementAny : array[0..2] of Integer = (65, 78, 89); {ANY}
|
|
Xpc_DTDElementCharData :
|
|
array[0..6] of Integer = (35, 80, 67, 68, 65, 84, 65); {#PCDATA}
|
|
Xpc_DTDElementEmpty :
|
|
array[0..4] of Integer = (69, 77, 80, 84, 89); {EMPTY}
|
|
Xpc_DTDEntity :
|
|
array[0..7] of Integer =
|
|
(60, 33, 69, 78, 84, 73, 84, 89); {<!ENTITY}
|
|
Xpc_DTDNotation :
|
|
array[0..9] of Integer =
|
|
(60, 33, 78, 79, 84, 65, 84, 73, 79, 78); {<!NOTATION}
|
|
Xpc_Encoding : array[0..7] of Integer =
|
|
(101, 110, 99, 111, 100, 105, 110, 103); {encoding}
|
|
Xpc_Equation : array[0..0] of Integer = (61); {=}
|
|
Xpc_ExternalPublic :
|
|
array[0..5] of Integer = (80, 85, 66, 76, 73, 67); {PUBLIC}
|
|
Xpc_ExternalSystem :
|
|
array[0..5] of Integer = (83, 89, 83, 84, 69, 77); {SYSTEM}
|
|
Xpc_GenParsedEntityEnd : array[0..0] of Integer = (59); {;}
|
|
Xpc_ListOperator : array[0..0] of Integer = (124); {|}
|
|
Xpc_MixedEnd : array[0..1] of Integer = (41, 42); {)*}
|
|
Xpc_OneOrMoreOpr : array[0..0] of Integer = (42); {*}
|
|
Xpc_ParamEntity : array[0..0] of Integer = (37); {%}
|
|
Xpc_ParenLeft : array[0..0] of Integer = (40); {(}
|
|
Xpc_ParenRight : array[0..0] of Integer = (41); {)}
|
|
Xpc_ProcessInstrEnd : array[0..1] of Integer = (63, 62); {?>}
|
|
Xpc_ProcessInstrStart : array[0..1] of Integer = (60, 63); {<?}
|
|
Xpc_QuoteDouble : array[0..0] of Integer = (34); {"}
|
|
Xpc_QuoteSingle : array[0..0] of Integer = (39); {'}
|
|
Xpc_Standalone :
|
|
array[0..9] of Integer =
|
|
(115, 116, 97, 110, 100, 97, 108, 111, 110, 101); {standalone}
|
|
Xpc_UnparsedEntity :
|
|
array[0..4] of Integer = (78, 68, 65, 84, 65); {NDATA}
|
|
Xpc_Version :
|
|
array[0..6] of Integer =
|
|
(118, 101, 114, 115, 105, 111, 110); {version}
|
|
|
|
const
|
|
LIT_CHAR_REF = 1;
|
|
LIT_ENTITY_REF = 2;
|
|
LIT_PE_REF = 4;
|
|
LIT_NORMALIZE = 8;
|
|
|
|
CONTEXT_NONE = 0;
|
|
CONTEXT_DTD = 1;
|
|
CONTEXT_ENTITYVALUE = 2;
|
|
CONTEXT_ATTRIBUTEVALUE = 3;
|
|
|
|
CONTENT_UNDECLARED = 0;
|
|
CONTENT_ANY = 1;
|
|
CONTENT_EMPTY = 2;
|
|
CONTENT_MIXED = 3;
|
|
CONTENT_ELEMENTS = 4;
|
|
|
|
OCCURS_REQ_NOREPEAT = 0;
|
|
OCCURS_OPT_NOREPEAT = 1;
|
|
OCCURS_OPT_REPEAT = 2;
|
|
OCCURS_REQ_REPEAT = 3;
|
|
|
|
REL_OR = 0;
|
|
REL_AND = 1;
|
|
REL_NONE = 2;
|
|
|
|
ATTRIBUTE_UNDECLARED = 0;
|
|
ATTRIBUTE_CDATA = 1;
|
|
ATTRIBUTE_ID = 2;
|
|
ATTRIBUTE_IDREF = 3;
|
|
ATTRIBUTE_IDREFS = 4;
|
|
ATTRIBUTE_ENTITY = 5;
|
|
ATTRIBUTE_ENTITIES = 6;
|
|
ATTRIBUTE_NMTOKEN = 7;
|
|
ATTRIBUTE_NMTOKENS = 8;
|
|
ATTRIBUTE_ENUMERATED = 9;
|
|
ATTRIBUTE_NOTATION = 10;
|
|
|
|
ATTRIBUTE_DEFAULT_UNDECLARED = 0;
|
|
ATTRIBUTE_DEFAULT_SPECIFIED = 1;
|
|
ATTRIBUTE_DEFAULT_IMPLIED = 2;
|
|
ATTRIBUTE_DEFAULT_REQUIRED = 3;
|
|
ATTRIBUTE_DEFAULT_FIXED = 4;
|
|
|
|
ENTITY_UNDECLARED = 0;
|
|
ENTITY_INTERNAL = 1;
|
|
ENTITY_NDATA = 2;
|
|
ENTITY_TEXT = 3;
|
|
|
|
CONDITIONAL_INCLUDE = 0;
|
|
CONDITIONAL_IGNORE = 1;
|
|
|
|
const
|
|
LineBufferSize = 4096;
|
|
type
|
|
TLineReader = class
|
|
protected
|
|
Buffer : array[0..LineBufferSize] of Ansichar;
|
|
fEOLF : Boolean;
|
|
ReadPtr : PAnsiChar;
|
|
fStream : TStream;
|
|
fBytesRead : Integer;
|
|
fFileSize : Integer;
|
|
procedure ReadPage;
|
|
public
|
|
property BytesRead : Integer read fBytesRead;
|
|
constructor Create(Stream : TStream);
|
|
destructor Destroy; override;
|
|
property EOLF : Boolean read fEOLF;
|
|
property FileSize : Integer read fFileSize;
|
|
function NextLine : AnsiString;
|
|
end;
|
|
|
|
{String handling class, only used by the TApdPager}
|
|
type
|
|
TAdStr = class
|
|
private
|
|
FMaxLen: Integer;
|
|
FLen: Integer;
|
|
FString: PChar;
|
|
FCur: PChar;
|
|
|
|
protected
|
|
procedure SetLen(NewLen: Integer);
|
|
function GetLen: Integer;
|
|
|
|
procedure SetMaxLen(NewMaxLen: Integer);
|
|
function GetMaxLen: Integer;
|
|
|
|
function GetBuffLen: Integer;
|
|
|
|
procedure SetChar(Index: Cardinal; Value: Char);
|
|
function GetChar(Index: Cardinal): Char;
|
|
|
|
function GetCurChar: Char;
|
|
|
|
public
|
|
constructor Create(AMaxLen: Cardinal);
|
|
destructor Destroy; override;
|
|
procedure Assign(Source: TAdStr);
|
|
|
|
property Len: Integer
|
|
read GetLen write SetLen;
|
|
property MaxLen: Integer
|
|
read GetMaxLen write SetMaxLen;
|
|
property BuffLen: Integer
|
|
read GetBuffLen;
|
|
property Chars[Index: Cardinal]: Char
|
|
read GetChar write SetChar; default;
|
|
property CurChar: Char
|
|
read GetCurChar;
|
|
property Str: PChar
|
|
read FString;
|
|
property Cur: PChar
|
|
read FCur;
|
|
|
|
procedure First;
|
|
procedure GotoPos(Index: Cardinal);
|
|
procedure Last;
|
|
procedure MoveBy(IndexBy: Integer);
|
|
procedure Next;
|
|
procedure Prev;
|
|
|
|
procedure Append(const Text: string); overload;
|
|
procedure Append(const Text: AnsiString); overload;
|
|
procedure AppendTAdStr(TS: TAdStr);
|
|
procedure AppendBuff(Buff: PChar);
|
|
procedure Clear;
|
|
function Copy(Index, SegLen: Integer): string; overload;
|
|
function CopyAnsi(Index, SegLen: Integer): AnsiString; overload;
|
|
procedure Delete(Index, SegLen: Integer);
|
|
procedure Insert(const Text: string; Index: Integer); overload;
|
|
procedure Insert(const Text: AnsiString; Index: Integer); overload;
|
|
function Pos(const SubStr: string): Cardinal;
|
|
function PosIdx(const SubStr: string; Index: Integer): Cardinal;
|
|
procedure Prepend(const Text: string); overload;
|
|
procedure Prepend(const Text: AnsiString); overload;
|
|
procedure Resize(NewLen: Integer);
|
|
end;
|
|
|
|
TAdStrCur = class
|
|
private
|
|
public
|
|
end;
|
|
|
|
{text converter data}
|
|
PTextFaxData = ^TTextFaxData;
|
|
TTextFaxData = record
|
|
IsExtended : Boolean; {Using extended text option?}
|
|
ReadBuffer : PByteArray; {Input buffer}
|
|
TabStop : Cardinal; {Number of spaces per tab character}
|
|
LineCount : Cardinal; {Number of text lines between page}
|
|
InFile : TLineReader; {Input file}
|
|
OnLine : DWORD; {Number of current input line}
|
|
CurRow : Cardinal; {Current raster row of CurStr}
|
|
CurStr : array[0..255] of Ansichar;
|
|
Pending : string;
|
|
FFPending : Boolean; {TRUE if formfeed pending}
|
|
FontRec : TFontRecord; {Holds current font info}
|
|
case Integer of
|
|
0: (FontLoaded : Bool; {False until font loaded}
|
|
FontPtr : PByteArray); {Pointer to the loaded font table}
|
|
1: (Bitmap : Graphics.TBitmap; {Memory bitmap for rendering text}
|
|
LineBytes : Cardinal; {Bytes per raster line}
|
|
Offset : Cardinal; {Current offset in the bitmap}
|
|
ImageSize : Integer; {Size of image structure}
|
|
ImageData : Pointer); {Image data}
|
|
end;
|
|
|
|
|
|
{TIFF strip information}
|
|
PStripRecord = ^TStripRecord;
|
|
TStripRecord = packed record
|
|
Offset : Integer;
|
|
Length : Integer;
|
|
end;
|
|
|
|
PStripInfo = ^TStripInfo;
|
|
TStripInfo = array[1..(65521 div SizeOf(TStripRecord))] of TStripRecord;
|
|
|
|
{TIFF converter data}
|
|
PTiffFaxData = ^TTiffFaxData;
|
|
TTiffFaxData = record
|
|
Intel : Bool; {TRUE if file is in Intel byte order}
|
|
LastBitMask : Word; {Last decode bit mask}
|
|
CurrRBSize : Cardinal; {Amount of data in read buffer}
|
|
CurrRBOfs : Cardinal; {Current offset in ReadBuffer}
|
|
OnStrip : Cardinal; {Current strip being processed}
|
|
OnRaster : Cardinal; {Current raster line being processed}
|
|
Version : Word; {Version number from file preable}
|
|
SubFile : Word; {TIFF tag field values for image:}
|
|
ImgWidth : Word; {image width}
|
|
ImgLen : Word; {length of image}
|
|
ImgBytes : Word; {bytes per raster line}
|
|
NumLines : Word; {image length (height)}
|
|
CompMethod : Word; {compression type}
|
|
PhotoMet : Word; {photometric conversion type}
|
|
RowStrip : DWORD; {raster lines per image strip}
|
|
StripOfs : Integer; {offset in file to first strip}
|
|
StripCnt : DWORD; {number of strips}
|
|
StripInfo : PStripInfo; {strip offsets/lengths}
|
|
ByteCntOfs : Integer; {offset to byte count list}
|
|
ImgStart : Integer; {start of image data in file}
|
|
ReadBuffer : PByteArray; {buffer for reads}
|
|
InFile : File; {input file}
|
|
end;
|
|
|
|
PDcxFaxData = ^TDcxFaxData;
|
|
TDcxFaxData = record
|
|
DcxHeader : TDcxHeaderRec; {Offsets to DCX pages}
|
|
DcxPgSz : TDcxOfsArray; {Number of bytes per PCX image}
|
|
DcxNumPag : Cardinal; {Number of pages (PCX images) in file}
|
|
OnPage : Cardinal; {Current page being converted}
|
|
end;
|
|
|
|
PPcxFaxData = ^TPcxFaxData;
|
|
TPcxFaxData = record
|
|
CurrRBSize : Cardinal; {Read buffer size}
|
|
CurrRBOfs : Cardinal; {Offset into read buffer}
|
|
ActBytesLine : Cardinal; {Actual number of bytes per line}
|
|
ReadBuffer : PByteArray; {Read buffer}
|
|
PcxHeader : TPcxHeaderRec; {Header from PCX image}
|
|
PcxBytes : DWORD; {Number of bytes in PCX image}
|
|
InFile : File; {Input file}
|
|
PcxWidth : Word; {Width of raster line in pixels}
|
|
DcxData : PDcxFaxData; {Optional DCX conversion data}
|
|
end;
|
|
|
|
const
|
|
DMSize = 32;
|
|
|
|
type
|
|
PBitmapFaxData = ^TBitmapFaxData;
|
|
TBitmapFaxData = record
|
|
BmpHandle : HBitmap;
|
|
DataBitmap : Graphics.TBitmap;
|
|
BytesPerLine : Cardinal;
|
|
Width : Cardinal;
|
|
NumLines : Cardinal;
|
|
OnLine : Cardinal;
|
|
Offset : Integer;
|
|
BitmapBufHandle : THandle;
|
|
BitmapBuf : Pointer;
|
|
NeedsDithering : Boolean;
|
|
DM : array[0..Pred(DMSize),0..Pred(DMSize)] of Integer;
|
|
end;
|
|
{$ENDIF}
|
|
{$ENDIF} {DrvInst}
|
|
|
|
{Fax unpacking}
|
|
|
|
{options passed to unpacker callback}
|
|
const
|
|
upStarting = $0001;
|
|
upEnding = $0002;
|
|
|
|
{flags passed to unpacker status}
|
|
const
|
|
usStarting = $0001;
|
|
usEnding = $0002;
|
|
|
|
const
|
|
{unpacker options}
|
|
ufYield = $0001;
|
|
ufAutoDoubleHeight = $0002;
|
|
ufAutoHalfWidth = $0004;
|
|
ufAbort = $0008;
|
|
|
|
DefUnpackOptions = ufYield or ufAutoDoubleHeight;
|
|
BadUnpackOptions = Cardinal(0);
|
|
|
|
{const number of raster lines per allocated page}
|
|
RasterBufferPageSize = Cardinal(1024);
|
|
|
|
type
|
|
{settings for horizontal and vertical scaling}
|
|
PScaleSettings = ^TScaleSettings;
|
|
TScaleSettings = record
|
|
HMult : Cardinal;
|
|
HDiv : Cardinal;
|
|
VMult : Cardinal;
|
|
VDiv : Cardinal;
|
|
end;
|
|
|
|
PUnpackFax = ^TUnpackFax;
|
|
|
|
{callback for outputting unpacked data}
|
|
TUnpackLineCallback = function(Unpack : PUnpackFax; plFlags : Word;
|
|
var Data; Len, PageNum : Cardinal) : Integer;
|
|
|
|
{callback for outputting status information}
|
|
TUnpackStatusCallback = procedure(Unpack : PUnpackFax; FaxFile : string;
|
|
PageNum : Cardinal; BytesUnpacked, BytesToUnpack : Integer);
|
|
|
|
{memory bitmap descriptor}
|
|
PMemoryBitmapDesc = ^TMemoryBitmapDesc;
|
|
TMemoryBitmapDesc = record
|
|
Width : Cardinal;
|
|
Height : Cardinal;
|
|
Bitmap : HBitmap;
|
|
end;
|
|
|
|
TUnpackFax = record
|
|
{basic unpacker data}
|
|
CurCode : Cardinal;
|
|
CurSig : Cardinal;
|
|
LineOfs : Cardinal; {Current offset in line}
|
|
LineBit : Cardinal; {Current offset in byte}
|
|
CurrPage : Cardinal; {Current page}
|
|
CurrLine : Cardinal; {Current line}
|
|
Flags : Cardinal; {Option flags}
|
|
BadCodes : Cardinal; {Number of bad codes unpacked}
|
|
WSFrom : Cardinal; {Whitespace comp - size of run to comp}
|
|
WSTo : Cardinal; {Number of lines to compress to}
|
|
WhiteCount : Cardinal; {Count of white lines unpacked}
|
|
TreeLast : Integer;
|
|
TreeNext : Integer;
|
|
Match : Integer;
|
|
ImgBytes : Integer;
|
|
ImgRead : Integer;
|
|
WhiteTree : PTreeArray; {Tree of white runlength codes}
|
|
BlackTree : PTreeArray; {Tree of black runlength codes}
|
|
LineBuffer : PByteArray; {Buffer for decompression}
|
|
TmpBuffer : PByteArray;
|
|
FileBuffer : PByteArray; {File I/O buffer}
|
|
FaxHeader : TFaxHeaderRec;
|
|
PageHeader : TPageHeaderRec;
|
|
OutputLine : TUnpackLineCallback; {Output a decompressed raster line}
|
|
Status : TUnpackStatusCallback;
|
|
UserData : Pointer; {Data needed by higher level unpackers}
|
|
|
|
{scaling data}
|
|
Height : Cardinal; {height of bitmap}
|
|
Width : Cardinal; {width of bitmap}
|
|
Handle : THandle; {handle to memory block}
|
|
Pages : Cardinal; {pages allocate in handle}
|
|
MaxWid : Cardinal; {maximum width of line}
|
|
Lines : Pointer; {raster lines}
|
|
Scale : TScaleSettings; {scale settings}
|
|
MemBmp : TMemoryBitmapDesc; {memory bitmap}
|
|
SaveHook : TUnpackLineCallback; {saved output line hook}
|
|
ToBuffer : Bool; {unpack to memory buffer?}
|
|
Inverted : Bool; {TRUE if bitmap data should be inverted}
|
|
end;
|
|
|
|
{data for unpacking to PCX file}
|
|
PUnpackToPcxData = ^TUnpackToPcxData;
|
|
TUnpackToPcxData = record
|
|
PBOfs : Cardinal;
|
|
Lines : Cardinal;
|
|
LastPage : Cardinal;
|
|
PCXOfs : Integer;
|
|
FileOpen : Bool;
|
|
DcxUnpack : Bool;
|
|
OutFile : File;
|
|
OutName : array[0..255] of AnsiChar;
|
|
PackBuffer : array[0..511] of Byte;
|
|
DcxHead : TDcxHeaderRec;
|
|
end;
|
|
|
|
{image converters}
|
|
const
|
|
DCXHeaderID = 987654321;
|
|
|
|
{Fax viewer}
|
|
|
|
const
|
|
{fax viewer window Cardinal}
|
|
gwl_Viewer = 0;
|
|
|
|
const
|
|
{special styles}
|
|
vws_DragDrop = $0001;
|
|
|
|
{default colors}
|
|
DefViewerBG = $FFFFFF;
|
|
DefViewerFG = $000000;
|
|
|
|
{default scrolling parameters}
|
|
DefVScrollInc = 8;
|
|
DefHScrollInc = 8;
|
|
|
|
{Abstract fax send/receive}
|
|
const
|
|
{Constants used to initialize object fields}
|
|
DefConnectAttempts : Cardinal = 1; {Default one connect attempt}
|
|
DefMaxRetries : Integer = 2; {Max times to retry sending a page}
|
|
DefStatusTimeout : Integer = 1; {Seconds between status updates}
|
|
|
|
{Constants used directly}
|
|
DefNormalInit : string = 'ATE0Q0V1X4S0=0S2=43'; {!!.04}
|
|
DefBlindInit : string = 'ATE0Q0V1X3S0=0S2=43'; {!!.04}
|
|
DefNoDetectBusyInit : string = 'ATE0Q0V1X2S0=0S2=43'; {!!.04}
|
|
DefX1Init : string = 'ATE0Q0V1X1S0=0S2=43'; {!!.04}
|
|
DefTapiInit : string = 'ATE0Q0V1S0=0S2=43'; {!!.04}
|
|
{DefInit = DefNormalInit;} {!!.04}
|
|
DefStatusBytes : Cardinal = 10000; {Force periodic exit}
|
|
MaxBadPercent : Cardinal = 10; {Error if this % bad training}
|
|
FlushWait : Cardinal = 500; {Msec before/after DTR drop}
|
|
FrameWait : Cardinal = 20; {Msec delay before HDLC frame}
|
|
|
|
{Fax send/receive options}
|
|
afAbortNoConnect = $0001; {Abort if no connect}
|
|
afExitOnError = $0002; {Exit FaxTransmit/Receive on error}
|
|
afCASSubmitUseControl = $0004; {SubmitSingleFile uses control file}
|
|
afSoftwareFlow = $0008; {Use software flow control in C1/2}
|
|
|
|
DefFaxOptions : Cardinal = 0;
|
|
BadFaxOptions = Cardinal(0);
|
|
|
|
{Fax types (for specifying different send/receive state machines}
|
|
ftNone = 0; {None specified}
|
|
ftClass12 = 1; {Class 1/2/2.0}
|
|
|
|
type
|
|
ClassType = (ctUnknown, ctDetect, ctClass1, ctClass2, ctClass2_0);
|
|
|
|
{Logging codes}
|
|
TFaxLogCode = (
|
|
lfaxNone,
|
|
lfaxTransmitStart,
|
|
lfaxTransmitOk,
|
|
lfaxTransmitFail,
|
|
lfaxReceiveStart,
|
|
lfaxReceiveOk,
|
|
lfaxReceiveSkip,
|
|
lfaxReceiveFail);
|
|
{ APRO components now use the TFaxLogCode exclusively, TLogFaxCode defined }
|
|
{ here for backwards compatibility }
|
|
TLogFaxCode = TFaxLogCode; {!!.04}
|
|
{Logging codes for TApdFaxServer}
|
|
TFaxServerLogCode = (
|
|
fslNone,
|
|
fslPollingEnabled,
|
|
fslPollingDisabled,
|
|
fslMonitoringEnabled,
|
|
fslMonitoringDisabled);
|
|
|
|
{General fax states}
|
|
FaxStateType = (
|
|
faxReady, {State machine ready immediately}
|
|
faxWaiting, {State machine waiting}
|
|
faxCritical, {State machine in critical state}
|
|
faxFinished); {State machine is finished}
|
|
|
|
type
|
|
{A list of files/numbers to fax}
|
|
TFaxNumber = String[40];
|
|
PFaxEntry = ^TFaxEntry;
|
|
TFaxEntry = record
|
|
fNumber : TFaxNumber;
|
|
fFName : ShortString;
|
|
fCover : ShortString;
|
|
fNext : PFaxEntry;
|
|
end;
|
|
|
|
{A general (Pascal and C++) structure for returning the next fax to send}
|
|
PSendFax = ^TSendFax;
|
|
TSendFax = record
|
|
sfNumber : array[0..40] of AnsiChar;
|
|
sfFName : array[0..255] of AnsiChar;
|
|
sfCover : array[0..255] of AnsiChar;
|
|
end;
|
|
|
|
const
|
|
{Trigger constants}
|
|
MaxTrigData = 21; {Max length of data trigger (should be odd)}
|
|
MaxDataPointers = 3; {Max number of data pointers}
|
|
TimerFreq = 50; {Dispatcher timer interval in millisecs}
|
|
|
|
{Data pointer constants}
|
|
dpProtocol = 1;
|
|
dpFax = 2;
|
|
dpModem = 3;
|
|
|
|
{Tracing constants}
|
|
MaxTraceCol = 78; {Wrap trace reports at this column}
|
|
HighestTrace = 4000000; {Largest acceptable trace buffer size}
|
|
|
|
{Logging constants}
|
|
MaxDLogQueueSize = 16000000; {Largest acceptable log queue}
|
|
|
|
type
|
|
{Types of dispatch entries}
|
|
TDispatchType = (
|
|
dtNone, dtDispatch, dtTrigger, dtError, dtThread,
|
|
dtTriggerAlloc, dtTriggerDispose, dtTriggerHandlerAlloc,
|
|
dtTriggerHandlerDispose, dtTriggerDataChange, dtTelnet, dtFax,
|
|
dtXModem, dtYModem, dtZModem, dtKermit, dtAscii, dtBPlus,
|
|
dtPacket, dtUser, dtScript);
|
|
TDispatchSubType =
|
|
(dstNone,
|
|
dstReadCom, dstWriteCom, dstLineStatus, dstModemStatus,
|
|
dstAvail, dstTimer, dstData, dstStatus,
|
|
dstThreadStart, dstThreadExit, dstThreadSleep, dstThreadWake,
|
|
dstDataTrigger, dstTimerTrigger, dstStatusTrigger, dstAvailTrigger,
|
|
dstWndHandler, dstProcHandler, dstEventHandler,
|
|
dstSWill, dstSWont, dstSDo, dstSDont, dstRWill, dstRWont,
|
|
dstRDo, dstRDont, dstCommand, dstSTerm,
|
|
dsttfNone, dsttfGetEntry, dsttfInit, dsttf1Init1, dsttf2Init1,
|
|
dsttf2Init1A, dsttf2Init1B, dsttf2Init2, dsttf2Init3, dsttfDial,
|
|
dsttfRetryWait, dsttf1Connect, dsttf1SendTSI, dsttf1TSIResponse,
|
|
dsttf1DCSResponse, dsttf1TrainStart, dsttf1TrainFinish,
|
|
dsttf1WaitCFR, dsttf1WaitPageConnect, dsttf2Connect,
|
|
dsttf2GetParams, dsttfWaitXon, dsttfWaitFreeHeader,
|
|
dsttfSendPageHeader, dsttfOpenCover, dsttfSendCover,
|
|
dsttfPrepPage, dsttfSendPage, dsttfDrainPage, dsttf1PageEnd,
|
|
dsttf1PrepareEOP, dsttf1SendEOP, dsttf1WaitMPS, dsttf1WaitEOP,
|
|
dsttf1WaitMCF, dsttf1SendDCN, dsttf1Hangup, dsttf1WaitHangup,
|
|
dsttf2SendEOP, dsttf2WaitFPTS, dsttf2WaitFET, dsttf2WaitPageOK,
|
|
dsttf2SendNewParams, dsttf2NextPage, dsttf20CheckPage,
|
|
dsttfClose, dsttfCompleteOK, dsttfAbort, dsttfDone, dstrfNone,
|
|
dstrfInit, dstrf1Init1, dstrf2Init1, dstrf2Init1A, dstrf2Init1B,
|
|
dstrf2Init2, dstrf2Init3, dstrfWaiting, dstrfAnswer,
|
|
dstrf1SendCSI, dstrf1SendDIS, dstrf1CollectFrames,
|
|
dstrf1CollectRetry1, dstrf1CollectRetry2, dstrf1StartTrain,
|
|
dstrf1CollectTrain, dstrf1Timeout, dstrf1Retrain,
|
|
dstrf1FinishTrain, dstrf1SendCFR, dstrf1WaitPageConnect,
|
|
dstrf2ValidConnect, dstrf2GetSenderID, dstrf2GetConnect,
|
|
dstrfStartPage, dstrfGetPageData, dstrf1FinishPage,
|
|
dstrf1WaitEOP, dstrf1WritePage, dstrf1SendMCF, dstrf1WaitDCN,
|
|
dstrf1WaitHangup, dstrf2GetPageResult, dstrf2GetFHNG,
|
|
dstrfComplete, dstrfAbort, dstrfDone,
|
|
dsttxInitial, dsttxHandshake, dsttxGetBlock, dsttxWaitFreeSpace,
|
|
dsttxSendBlock, dsttxDraining, dsttxReplyPending,
|
|
dsttxEndDrain, dsttxFirstEndOfTransmit, dsttxRestEndOfTransmit,
|
|
dsttxEotReply, dsttxFinished, dsttxDone,
|
|
dstrxInitial, dstrxWaitForHSReply, dstrxWaitForBlockStart,
|
|
dstrxCollectBlock, dstrxProcessBlock, dstrxFinishedSkip,
|
|
dstrxFinished, dstrxDone,
|
|
dsttyInitial, dsttyHandshake, dsttyGetFileName, dsttySendFileName,
|
|
dsttyDraining, dsttyReplyPending, dsttyPrepXmodem,
|
|
dsttySendXmodem, dsttyFinished, dsttyFinishDrain, dsttyDone,
|
|
dstryInitial, dstryDelay, dstryWaitForHSReply,
|
|
dstryWaitForBlockStart, dstryCollectBlock, dstryProcessBlock,
|
|
dstryOpenFile, dstryPrepXmodem, dstryReceiveXmodem, dstryFinished,
|
|
dstryDone, dsttzInitial, dsttzHandshake, dsttzGetFile,
|
|
dsttzSendFile, dsttzCheckFile, dsttzStartData, dsttzEscapeData,
|
|
dsttzSendData, dsttzWaitAck, dsttzSendEof, dsttzDrainEof,
|
|
dsttzCheckEof, dsttzSendFinish, dsttzCheckFinish, dsttzError,
|
|
dsttzCleanup, dsttzDone, dstrzRqstFile, dstrzDelay, dstrzWaitFile,
|
|
dstrzCollectFile, dstrzSendInit, dstrzSendBlockPrep,
|
|
dstrzSendBlock, dstrzSync, dstrzStartFile, dstrzStartData,
|
|
dstrzCollectData, dstrzGotData, dstrzWaitEof, dstrzEndOfFile,
|
|
dstrzSendFinish, dstrzCollectFinish, dstrzError, dstrzWaitCancel,
|
|
dstrzCleanup, dstrzDone,
|
|
dsttkInit, dsttkInitReply, dsttkCollectInit, dsttkOpenFile,
|
|
dsttkSendFile, dsttkFileReply, dsttkCollectFile, dsttkCheckTable,
|
|
dsttkSendData, dsttkBlockReply, dsttkCollectBlock, dsttkSendEof,
|
|
dsttkEofReply, dsttkCollectEof, dsttkSendBreak, dsttkBreakReply,
|
|
dsttkCollectBreak, dsttkComplete, dsttkWaitCancel, dsttkError,
|
|
dsttkDone, dstrkInit, dstrkGetInit, dstrkCollectInit,
|
|
dstrkGetFile, dstrkCollectFile, dstrkGetData, dstrkCollectData,
|
|
dstrkComplete, dstrkWaitCancel, dstrkError, dstrkDone,
|
|
dsttaInitial, dsttaGetBlock, dsttaWaitFreeSpace, dsttaSendBlock,
|
|
dsttaSendDelay, dsttaFinishDrain, dsttaFinished, dsttaDone,
|
|
dstraInitial, dstraCollectBlock, dstraProcessBlock,
|
|
dstraFinished, dstraDone, dstEnable, dstDisable, dstStringPacket,
|
|
dstSizePacket, dstPacketTimeout, dstStartStr, dstEndStr,
|
|
dstIdle, dstWaiting, dstCollecting, dstThreadStatusQueued, // SWB
|
|
dstThreadDataQueued, dstThreadDataWritten, dsttzSinit, // SWB
|
|
dsttzCheckSInit // SWB
|
|
);
|
|
|
|
{For holding trace entries}
|
|
TTraceRecord = record
|
|
EventType : AnsiChar;
|
|
C : AnsiChar;
|
|
end;
|
|
PTraceQueue = ^TTraceQueue;
|
|
TTraceQueue = array[0..HighestTrace] of TTraceRecord;
|
|
|
|
{DispatchBuffer type}
|
|
PDBuffer = ^TDBuffer;
|
|
TDBuffer = array[0..65527] of AnsiChar;
|
|
|
|
{Output buffer type}
|
|
POBuffer = ^TOBuffer;
|
|
TOBuffer = array[0..pred(High(Integer))] of AnsiChar;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
|
|
{For storing com name}
|
|
TComName = array[0..5] of Char;
|
|
|
|
{Trigger types}
|
|
TTriggerType = (ttNone, ttAvail, ttTimer, ttData, ttStatus);
|
|
|
|
{Timer trigger record}
|
|
PTimerTrigger = ^TTimerTrigger;
|
|
TTimerTrigger = record
|
|
tHandle : Cardinal;
|
|
tET : EventTimer;
|
|
tTicks : Integer;
|
|
tValid : Bool;
|
|
tActive : Bool;
|
|
end;
|
|
|
|
{Data trigger match array}
|
|
TCheckIndex = array[0..MaxTrigData] of Cardinal;
|
|
|
|
{Data trigger record}
|
|
PDataTrigger = ^TDataTrigger;
|
|
TDataTrigger = record
|
|
tHandle : Cardinal;
|
|
tLen : Cardinal;
|
|
tChkIndex : TCheckIndex;
|
|
tMatched : Bool;
|
|
tIgnoreCase : Bool;
|
|
tData : array[0..MaxTrigData] of AnsiChar;
|
|
end;
|
|
|
|
{Status trigger record}
|
|
PStatusTrigger = ^TStatusTrigger;
|
|
TStatusTrigger = record
|
|
tHandle : Cardinal;
|
|
tSType : Cardinal;
|
|
tValue : Word;
|
|
tSActive : Boolean;
|
|
StatusHit : Boolean;
|
|
end;
|
|
|
|
{Trigger save record}
|
|
TTriggerSave = record
|
|
tsLenTrigger : Cardinal;
|
|
tsTimerTriggers : Tlist;
|
|
tsDataTriggers : TList;
|
|
tsStatusTriggers : TList;
|
|
end;
|
|
|
|
{Trigger handler records}
|
|
PWndTriggerHandler = ^TWndTriggerHandler;
|
|
TWndTriggerHandler = record
|
|
thWnd : TApdHwnd; {Window that gets messages}
|
|
thDeleted : Boolean;
|
|
end;
|
|
PProcTriggerHandler = ^TProcTriggerHandler;
|
|
TProcTriggerHandler = record
|
|
thNotify : TApdNotifyProc; {Address of notification proc}
|
|
thDeleted : Boolean;
|
|
end;
|
|
PEventTriggerHandler = ^TEventTriggerHandler;
|
|
TEventTriggerHandler = record
|
|
thNotify : TApdNotifyEvent; {Address of notification event}
|
|
thDeleted : Boolean;
|
|
thSync : Boolean;
|
|
end;
|
|
{Data pointers for various purposes}
|
|
TDataPointerArray = array[1..MaxDataPointers] of Pointer;
|
|
{indexes in use internally (each component must use unique index) :
|
|
1 : protocol component
|
|
2 : fax component
|
|
3 : legacy modem component
|
|
}
|
|
{$ENDIF}
|
|
|
|
procedure SetFlag(var Flags : Cardinal; FlagMask : Cardinal);
|
|
|
|
procedure ClearFlag(var Flags : Cardinal; FlagMask : Cardinal);
|
|
|
|
function FlagIsSet(Flags : Cardinal; FlagMask : Cardinal) : Bool;
|
|
|
|
procedure SetByteFlag(var Flags : Byte; FlagMask : Byte);
|
|
|
|
procedure ClearByteFlag(var Flags : Byte; FlagMask : Byte);
|
|
|
|
function ByteFlagIsSet(Flags : Byte; FlagMask : Byte) : Bool;
|
|
|
|
function MinWord(A, B : Cardinal) : Cardinal;
|
|
|
|
function AddWordToPtr(P : Pointer; W : Cardinal) : Pointer;
|
|
|
|
function AdTimeGetTime : DWord;
|
|
|
|
function Ticks2Secs(Ticks : Integer) : Integer;
|
|
function Secs2Ticks(Secs : Integer) : Integer;
|
|
function MSecs2Ticks(MSecs : Integer) : Integer;
|
|
procedure NewTimer(var ET : EventTimer; Ticks : Integer);
|
|
procedure NewTimerSecs(var ET : EventTimer; Secs : Integer);
|
|
function TimerExpired(ET : EventTimer) : Bool;
|
|
function ElapsedTime(ET : EventTimer) : Integer;
|
|
function ElapsedTimeInSecs(ET : EventTimer) : Integer;
|
|
function RemainingTime(ET : EventTimer) : Integer;
|
|
function RemainingTimeInSecs(ET : EventTimer) : Integer;
|
|
function DelayTicks(Ticks: Integer; Yield : Bool) : Integer;
|
|
{$IFNDEF PrnDrv}
|
|
function Long2StrZ(Dest : PChar; L : Integer) : PChar;
|
|
function Str2LongZ(S : PChar; var I : Integer) : Bool;
|
|
{$ENDIF}
|
|
function JustPathnameZ(out Dest : string; PathName : string) : string; overload;
|
|
function JustPathnameZ(Dest : PAnsiChar; PathName : PAnsiChar) : PAnsiChar; overload;
|
|
function JustFilenameZ(Dest : PAnsiChar; PathName : PAnsiChar) : PAnsiChar;
|
|
{$IFNDEF PrnDrv}
|
|
function JustExtensionZ(out Dest : string; Name : string) : string; overload;
|
|
{$ENDIF}
|
|
function StrStCopy(Dest : PWideChar; S : PWideChar; Pos, Count : Cardinal) : PWideChar; overload;
|
|
function StrStCopy(Dest : PAnsiChar; S : PAnsiChar; Pos, Count : Cardinal) : PAnsiChar; overload;
|
|
function AddBackSlashZ(Dest : PAnsiChar; DirName : PAnsiChar) : PAnsiChar; overload;
|
|
function AddBackSlashZ(out Dest : string; DirName : string) : string; overload;
|
|
{$IFNDEF PrnDrv}
|
|
function ExistFileZ(FName : string) : Bool; overload;
|
|
{$ENDIF}
|
|
function ForceExtensionZ(out Dest : string; Name, Ext : string) : string; overload;
|
|
function DefaultExtensionZ(out Dest : string; Name, Ext : string) : string; overload;
|
|
function GetPtr(P : Pointer; O : Integer) : Pointer;
|
|
procedure NotBuffer(var Buf; Len : Cardinal);
|
|
|
|
{$IFNDEF Win32}
|
|
{$IFNDEF Win64}
|
|
function Trim(const S : string) : string;
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
|
|
function DelayMS(MS : Cardinal) : Cardinal;
|
|
|
|
function SafeYield : Integer;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function JustName(PathName : String) : String;
|
|
{-Return just the name (no extension, no path) of a pathname}
|
|
|
|
function AddBackSlash(const DirName : String) : String; overload;
|
|
{-Add a default backslash to a directory name}
|
|
|
|
function AddBackSlash(const DirName : AnsiString) : AnsiString; overload;
|
|
{-Add a default backslash to a directory name}
|
|
|
|
function IsWin2000 : Boolean;
|
|
{- Returns True if running on Windows 2000 }
|
|
|
|
function IsWinNT : Boolean;
|
|
{- Returns True is we are running on an NT platform (NT4 or 2K }
|
|
|
|
{ Base class definitions, this is how we get this unit automatically }
|
|
{ added to the uses clause when a component is dropped on the form. }
|
|
type
|
|
TApdBaseComponent = class(TComponent)
|
|
protected
|
|
function GetVersion : string;
|
|
procedure SetVersion(const Value : string);
|
|
published
|
|
property Version : string
|
|
read GetVersion
|
|
write SetVersion
|
|
stored False;
|
|
end;
|
|
|
|
TApdBaseWinControl = class(TWinControl)
|
|
protected
|
|
function GetVersion : string;
|
|
procedure SetVersion(const Value : string);
|
|
published
|
|
property Version : string
|
|
read GetVersion
|
|
write SetVersion
|
|
stored False;
|
|
end;
|
|
|
|
TApdBaseOleControl = class(TOleControl)
|
|
protected
|
|
function GetVersion : string;
|
|
procedure SetVersion (const Value : string);
|
|
published
|
|
property Version : string
|
|
read GetVersion
|
|
write SetVersion
|
|
stored False;
|
|
end;
|
|
|
|
TApdBaseGraphicControl = class(TGraphicControl)
|
|
protected
|
|
function GetVersion : string;
|
|
procedure SetVersion (const Value : string);
|
|
published
|
|
property Version : string
|
|
read GetVersion
|
|
write SetVersion
|
|
stored False;
|
|
end;
|
|
|
|
TApdBaseScrollingWinControl = class(TScrollingWinControl)
|
|
protected
|
|
function GetVersion : string;
|
|
procedure SetVersion (const Value : string);
|
|
published
|
|
property Version : string
|
|
read GetVersion
|
|
write SetVersion
|
|
stored False;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
|
|
|
|
function ApWinExecAndWait32(FileName : PChar; CommandLine : PChar;
|
|
Visibility : Integer) : Integer;
|
|
|
|
{$IFDEF Apax}
|
|
procedure WriteDebug(const S : string);
|
|
{$ENDIF}
|
|
|
|
{ These methods were overloaded to work around a Delphi 6 bug. }
|
|
procedure AssignFile(var F: File; const FileName: string); overload;
|
|
procedure AssignFile(var F: TextFile; const FileName : string); overload;
|
|
procedure Assign(var F: File; const FileName: string); overload;
|
|
procedure Assign(var F: TextFile; const FileName: string); overload;
|
|
|
|
implementation
|
|
|
|
uses
|
|
AnsiStrings;
|
|
|
|
function StrLenW(const Str: PWideChar): Cardinal;
|
|
asm
|
|
cmp word ptr [eax], 0
|
|
je @ZeroLen
|
|
mov edx, eax
|
|
neg edx
|
|
@MyLoop:
|
|
mov cx, [eax]
|
|
add eax, 2
|
|
test cx, cx
|
|
jnz @MyLoop
|
|
lea eax, [eax + edx - 2]
|
|
shr eax, 1
|
|
ret
|
|
@ZeroLen:
|
|
xor eax, eax
|
|
end;
|
|
|
|
{$IFDEF APAX}
|
|
procedure WriteDebug(const S : Ansistring);
|
|
var
|
|
LogStream : TFileStream;
|
|
TimeStamp : Ansistring;
|
|
begin
|
|
LogStream := nil;
|
|
try
|
|
if FileExists('APAXDBG.TXT') then
|
|
LogStream := TFileStream.Create('APAXDBG.TXT', fmOpenReadWrite or fmShareDenyNone)
|
|
else
|
|
LogStream := TFileStream.Create('APAXDBG.TXT', fmCreate or fmShareDenyNone);
|
|
LogStream.Seek(0, soFromEnd);
|
|
TimeStamp := FormatDateTime('dd/mm/yy : hh:mm:ss - ', Now) + S + #13#10;
|
|
LogStream.WriteBuffer(TimeStamp[1], Length(TimeStamp));
|
|
OutputDebugStringA(PAnsiChar(S)); // WriteLn(S);
|
|
|
|
finally
|
|
LogStream.Free;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure AssignFile(var F: File; const FileName: string);
|
|
begin
|
|
System.AssignFile(F, FileName);
|
|
end;
|
|
|
|
procedure AssignFile(var F: TextFile; const FileName : string);
|
|
begin
|
|
System.AssignFile(F, FileName);
|
|
end;
|
|
|
|
procedure Assign(var F: File; const FileName: string);
|
|
begin
|
|
System.Assign(F, FileName);
|
|
end;
|
|
|
|
procedure Assign(var F: TextFile; const FileName: string);
|
|
begin
|
|
System.Assign(F, FileName);
|
|
end;
|
|
|
|
|
|
const
|
|
MaxTicks = 39045157; {Max ticks, 24.8 days}
|
|
|
|
{Clock frequency of 1193180/65536 is reduced to 1675/92. This}
|
|
{allows Integer conversions of Ticks values upto TicksPerDay}
|
|
TicksFreq = 1675;
|
|
SecsFreq = 92;
|
|
MSecsFreq = 92000;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
{$IFNDEF DrvInst}
|
|
constructor TLineReader.Create(Stream : TStream);
|
|
begin
|
|
fStream := Stream;
|
|
fFileSize := fStream.Size;
|
|
fBytesRead := 0;
|
|
ReadPage;
|
|
end;
|
|
|
|
destructor TLineReader.Destroy;
|
|
begin
|
|
fStream.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TLineReader.NextLine : AnsiString;
|
|
var
|
|
EOL : PAnsiChar;
|
|
Done : Boolean;
|
|
begin
|
|
Result := '';
|
|
repeat
|
|
Done := True;
|
|
EOL := AnsiStrings.StrScan(ReadPtr,#13);
|
|
if EOL <> nil then begin
|
|
EOL^ := #0;
|
|
Result := Result + AnsiStrings.StrPas(ReadPtr);
|
|
ReadPtr := EOL;
|
|
inc(ReadPtr);
|
|
if ReadPtr^ = #10 then inc(ReadPtr);
|
|
end else begin
|
|
Result := Result + AnsiStrings.StrPas(ReadPtr);
|
|
ReadPage;
|
|
Done := EOLF;
|
|
end;
|
|
until Done;
|
|
end;
|
|
|
|
procedure TLineReader.ReadPage;
|
|
var
|
|
BytesRead : Integer;
|
|
begin
|
|
BytesRead := fStream.Read(Buffer,LineBufferSize);
|
|
inc(fBytesRead,BytesRead);
|
|
fEOLF := BytesRead = 0;
|
|
if (fEOLF) then // SWB
|
|
Buffer[0] := #0 // SWB
|
|
else // SWB
|
|
begin // SWB
|
|
{ if we're at the end of the file, make sure it has the line term char }
|
|
if (BytesRead<LineBufferSize) and {!!.04}
|
|
not(Buffer[BytesRead-1] in [#13,#$1A]) then {!!.04}
|
|
Buffer[BytesRead] := #13; {!!.04}
|
|
ReadPtr := @Buffer[0];
|
|
if ReadPtr^ = #10 then inc(ReadPtr);
|
|
// if {not} fEOLF then {!!.04} // SWB
|
|
if Buffer[BytesRead-1] = #$1A then
|
|
Buffer[BytesRead-1] := #0
|
|
else
|
|
Buffer[BytesRead] := #0;
|
|
end;
|
|
end; // SWB
|
|
|
|
{ TAdStr }
|
|
|
|
constructor TAdStr.Create(AMaxLen: Cardinal);
|
|
begin
|
|
inherited Create;
|
|
FMaxLen := 0;
|
|
FLen := 0;
|
|
FString := nil;
|
|
SetMaxLen(AMaxLen);
|
|
end;
|
|
|
|
destructor TAdStr.Destroy;
|
|
begin
|
|
if Assigned(FString) then
|
|
FreeMem(FString, FMaxLen + 1);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TAdStr.Append(const Text: string);
|
|
var
|
|
NewLen: Integer;
|
|
Buff: PChar;
|
|
begin
|
|
if Text = '' then Exit; { nothing to append }
|
|
|
|
NewLen := Length(Text) + FLen;
|
|
if NewLen > FMaxLen then { if new text will be longer than allocated }
|
|
Resize(NewLen); { reallocate }
|
|
|
|
Buff := StrAlloc(Length(Text) + 1);
|
|
StrPCopy(Buff,Text);
|
|
StrCat(FString, Buff);
|
|
StrDispose(Buff);
|
|
FLen := StrLen(FString);
|
|
end;
|
|
|
|
procedure TAdStr.Append(const Text: AnsiString);
|
|
begin
|
|
Append(string(Text));
|
|
end;
|
|
|
|
procedure TAdStr.AppendBuff(Buff: PChar);
|
|
var
|
|
BuffLen: Integer;
|
|
begin
|
|
BuffLen := StrLen(Buff);
|
|
if BuffLen = 0 then Exit;
|
|
|
|
if BuffLen + FLen > FMaxLen then
|
|
Resize(BuffLen + FLen);
|
|
|
|
StrCat(FString, Buff);
|
|
FLen := StrLen(FString);
|
|
end;
|
|
|
|
procedure TAdStr.AppendTAdStr(TS: TAdStr);
|
|
begin
|
|
AppendBuff(TS.Str);
|
|
end;
|
|
|
|
procedure TAdStr.Assign(Source: TAdStr);
|
|
begin
|
|
if not Assigned(Source) then Exit;
|
|
|
|
if Source.MaxLen <> MaxLen then
|
|
Resize(Source.MaxLen);
|
|
|
|
FMaxLen := Source.MaxLen;
|
|
|
|
StrCopy(FString, Source.Str);
|
|
FLen := StrLen(FString);
|
|
|
|
GotoPos(Source.Cur - Source.Str);
|
|
end;
|
|
|
|
procedure TAdStr.Clear;
|
|
begin
|
|
FString[0] := #0;
|
|
FLen := 0;
|
|
FCur := FString;
|
|
end;
|
|
|
|
function TAdStr.Copy(Index, SegLen: Integer): string;
|
|
var
|
|
P:PChar;
|
|
NewLen: Integer;
|
|
begin
|
|
if (Index = 0) or (SegLen = 0) or (Index > FLen) then begin
|
|
Result := '';
|
|
Exit;
|
|
end;
|
|
|
|
NewLen := SegLen;
|
|
if Index + (SegLen - 1) > FLen then { requested segment runs past end of string }
|
|
NewLen := FLen - Index; { just return up to end of string }
|
|
|
|
GotoPos(Index);
|
|
|
|
P := StrAlloc(NewLen + 1);
|
|
StrLCopy(P, FCur, NewLen);
|
|
Result := StrPas(P);
|
|
StrDispose(P);
|
|
end;
|
|
|
|
function TAdStr.CopyAnsi(Index, SegLen: Integer): AnsiString;
|
|
begin
|
|
Result := AnsiString(Copy(Index, SegLen));
|
|
end;
|
|
|
|
procedure TAdStr.Delete(Index, SegLen: Integer);
|
|
var
|
|
Src: PChar;
|
|
SrcLen: Cardinal;
|
|
begin
|
|
if (Index = 0) or (SegLen = 0) or (Index > FLen) then Exit;
|
|
|
|
GotoPos(Index); { locate starting point }
|
|
if Index + (SegLen - 1) > FLen then { delete rest of string }
|
|
FCur[0] := #0
|
|
else begin { remove chunk }
|
|
Src := FCur + SegLen; { find start of remain post chunk string }
|
|
SrcLen := StrLen(Src);
|
|
StrLCopy(FCur, Src, SrcLen);
|
|
end;
|
|
FLen := StrLen(FString);
|
|
end;
|
|
|
|
procedure TAdStr.First;
|
|
begin
|
|
FCur := FString;
|
|
end;
|
|
|
|
function TAdStr.GetBuffLen: Integer;
|
|
begin
|
|
Result := FMaxLen + 1;
|
|
end;
|
|
|
|
function TAdStr.GetChar(Index: Cardinal): Char;
|
|
begin
|
|
Result := FString[Index];
|
|
end;
|
|
|
|
function TAdStr.GetCurChar: Char;
|
|
begin
|
|
Result := FCur[0];
|
|
end;
|
|
|
|
function TAdStr.GetLen: Integer;
|
|
begin
|
|
Result := FLen;
|
|
end;
|
|
|
|
function TAdStr.GetMaxLen: Integer;
|
|
begin
|
|
Result := FMaxLen;
|
|
end;
|
|
|
|
procedure TAdStr.GotoPos(Index: Cardinal);
|
|
begin
|
|
FCur := FString;
|
|
Inc(FCur, Index-1);
|
|
end;
|
|
|
|
procedure TAdStr.Insert(const Text: string; Index: Integer);
|
|
var
|
|
Buff: PChar;
|
|
NewLen: Integer;
|
|
begin
|
|
if (Index = 0) or (Index > FLen) or (Text = '') then Exit;
|
|
|
|
NewLen := Length(Text) + FLen;
|
|
if NewLen > FMaxLen then { if new text will be longer than allocated }
|
|
Resize(NewLen); { reallocate }
|
|
|
|
GotoPos(Index); { find insertion point }
|
|
Buff := StrNew(FCur); { make copy of rest of string }
|
|
StrPCopy(FCur, Text); { append Text at insertion point }
|
|
StrCat(FString, Buff); { add rest of string back on }
|
|
StrDispose(Buff);
|
|
FLen := StrLen(FString);
|
|
end;
|
|
|
|
procedure TAdStr.Insert(const Text: AnsiString; Index: Integer);
|
|
begin
|
|
Insert(string(Text), Index);
|
|
end;
|
|
|
|
procedure TAdStr.Last;
|
|
begin
|
|
FCur := StrEnd(FString) - 1;
|
|
end;
|
|
|
|
procedure TAdStr.Resize(NewLen: Integer);
|
|
var
|
|
Temp: PChar;
|
|
TempLen: Cardinal;
|
|
begin
|
|
Temp := StrNew(FString);
|
|
if (NewLen - 1) < FLen then
|
|
TempLen := NewLen - 1
|
|
else
|
|
TempLen := FLen;
|
|
SetMaxLen(NewLen);
|
|
StrLCopy(FString, Temp, TempLen);
|
|
StrDispose(Temp);
|
|
FLen := StrLen(FString)
|
|
end;
|
|
|
|
procedure TAdStr.MoveBy(IndexBy: Integer);
|
|
begin
|
|
if IndexBy < 0 then
|
|
Dec(FCur, IndexBy)
|
|
else
|
|
if IndexBy > 0 then
|
|
Inc(FCur, IndexBy)
|
|
else
|
|
{no change};
|
|
end;
|
|
|
|
procedure TAdStr.Next;
|
|
begin
|
|
Inc(FCur, 1);
|
|
end;
|
|
|
|
function TAdStr.Pos(const SubStr: string): Cardinal;
|
|
var
|
|
Buff: PChar;
|
|
begin
|
|
Buff := StrAlloc(Length(SubStr) + 1);
|
|
StrPCopy(Buff,SubStr);
|
|
FCur := StrPos(FString, Buff);
|
|
StrDispose(Buff);
|
|
|
|
if FCur = nil then
|
|
Result := 0
|
|
else
|
|
Result := FCur - FString + 1;
|
|
end;
|
|
|
|
function TAdStr.PosIdx(const SubStr: string; Index: Integer): Cardinal;
|
|
var
|
|
Buff: PChar;
|
|
begin
|
|
if (Index = 0) or (Index > FLen) then begin
|
|
Result := 0 ;
|
|
Exit ;
|
|
end;
|
|
|
|
GetMem(Buff, Length(SubStr) + 5);
|
|
GotoPos(Index);
|
|
FCur := StrPos(FCur, StrPCopy(Buff,SubStr));
|
|
StrDispose(Buff);
|
|
|
|
if FCur = nil then
|
|
Result := 0
|
|
else
|
|
Result := FCur - FString + 1;
|
|
end;
|
|
|
|
procedure TAdStr.Prepend(const Text: string);
|
|
begin
|
|
Insert(Text,1);
|
|
end;
|
|
|
|
procedure TAdStr.Prepend(const Text: AnsiString);
|
|
begin
|
|
Insert(string(Text), 1);
|
|
end;
|
|
|
|
procedure TAdStr.Prev;
|
|
begin
|
|
Dec(FCur,1);
|
|
end;
|
|
|
|
procedure TAdStr.SetChar(Index: Cardinal; Value: Char);
|
|
begin
|
|
if FString[Index] <> Value then
|
|
FString[Index] := Value;
|
|
end;
|
|
|
|
procedure TAdStr.SetLen(NewLen: Integer);
|
|
begin
|
|
if NewLen <= FLen then
|
|
FString[NewLen] := #0;
|
|
end;
|
|
|
|
procedure TAdStr.SetMaxLen(NewMaxLen: Integer);
|
|
begin
|
|
if FMaxLen <> NewMaxLen then begin
|
|
if Assigned(FString) then
|
|
FreeMem(FString, FMaxLen + 5);
|
|
FMaxLen := NewMaxLen;
|
|
if FMaxLen = 0 then
|
|
FString := nil
|
|
else
|
|
GetMem(FString, FMaxLen + 5);
|
|
end;
|
|
|
|
if Assigned(FString) then
|
|
FString[0] := #0;
|
|
FLen := 0;
|
|
end;
|
|
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
|
|
function MinWord(A, B : Cardinal) : Cardinal;
|
|
begin
|
|
if A < B then
|
|
Result := A
|
|
else
|
|
Result := B;
|
|
end;
|
|
|
|
function FlagIsSet(Flags : Cardinal; FlagMask : Cardinal) : Bool;
|
|
begin
|
|
FlagIsSet := (Flags and FlagMask) <> 0;
|
|
end;
|
|
|
|
procedure ClearFlag(var Flags : Cardinal; FlagMask : Cardinal);
|
|
begin
|
|
Flags := Flags and not FlagMask;
|
|
end;
|
|
|
|
procedure SetFlag(var Flags : Cardinal; FlagMask : Cardinal);
|
|
begin
|
|
Flags := Flags or FlagMask;
|
|
end;
|
|
|
|
function ByteFlagIsSet(Flags : Byte; FlagMask : Byte) : Bool;
|
|
begin
|
|
ByteFlagIsSet := (Flags and FlagMask) <> 0;
|
|
end;
|
|
|
|
procedure ClearByteFlag(var Flags : Byte; FlagMask : Byte);
|
|
begin
|
|
Flags := Flags and not FlagMask;
|
|
end;
|
|
|
|
procedure SetByteFlag(var Flags : Byte; FlagMask : Byte);
|
|
begin
|
|
Flags := Flags or FlagMask;
|
|
end;
|
|
|
|
function AddWordToPtr(P : Pointer; W : Cardinal) : Pointer; assembler;
|
|
asm
|
|
add eax,edx
|
|
end;
|
|
|
|
const
|
|
DosDelimSet : set of AnsiChar = ['\', ':', #0];
|
|
|
|
MaxPCharLen = $7FFFFFFF;
|
|
|
|
function SafeYield : Integer;
|
|
{-Allow other processes a chance to run}
|
|
var
|
|
Msg : TMsg;
|
|
begin
|
|
SafeYield := 0;
|
|
if PeekMessage(Msg, 0, 0, 0, PM_REMOVE) then begin
|
|
if Msg.Message = wm_Quit then
|
|
{Re-post quit message so main message loop will terminate}
|
|
PostQuitMessage(Msg.WParam)
|
|
else begin
|
|
TranslateMessage(Msg);
|
|
DispatchMessage(Msg);
|
|
end;
|
|
{Return message so caller can act on message if necessary}
|
|
SafeYield := MAKELONG(Msg.Message, Msg.hwnd);
|
|
end;
|
|
end;
|
|
|
|
{ Centralized timer method, return is the number of ms since the system started }
|
|
function AdTimeGetTime : DWord;
|
|
begin
|
|
Result := timeGetTime; // SWB
|
|
end;
|
|
|
|
function Ticks2Secs(Ticks : Integer) : Integer;
|
|
{-Returns seconds value for Ticks Ticks}
|
|
begin
|
|
Ticks2Secs := ((Ticks + 9) * SecsFreq) div TicksFreq;
|
|
end;
|
|
|
|
function Secs2Ticks(Secs : Integer) : Integer;
|
|
{-Returns Ticks value for Secs seconds}
|
|
begin
|
|
Secs2Ticks := (Secs * TicksFreq) div SecsFreq;
|
|
end;
|
|
|
|
function MSecs2Ticks(MSecs : Integer) : Integer;
|
|
{-Returns Ticks value for msecs}
|
|
begin
|
|
Result := (MSecs * TicksFreq) div MSecsFreq;
|
|
end;
|
|
|
|
procedure NewTimer(var ET : EventTimer; Ticks : Integer);
|
|
{-Returns a set EventTimer that will expire in Ticks}
|
|
begin
|
|
{Max acceptable value is MaxTicks}
|
|
if Ticks > MaxTicks then
|
|
Ticks := MaxTicks;
|
|
|
|
with ET do begin
|
|
StartTicks := AdTimeGetTime div 55;
|
|
ExpireTicks := StartTicks + Ticks;
|
|
end;
|
|
end;
|
|
|
|
procedure NewTimerSecs(var ET : EventTimer; Secs : Integer);
|
|
{-Returns a set EventTimer}
|
|
begin
|
|
NewTimer(ET, Secs2Ticks(Secs));
|
|
end;
|
|
|
|
function TimerExpired(ET : EventTimer) : Bool;
|
|
{-Returns True if ET has expired}
|
|
var
|
|
CurTicks : Integer;
|
|
begin
|
|
with ET do begin
|
|
{Get current Ticks; assume timer has expired}
|
|
CurTicks := AdTimeGetTime div 55;
|
|
TimerExpired := True;
|
|
{Check normal expiration}
|
|
if CurTicks > ExpireTicks then
|
|
Exit;
|
|
{Check wrapped CurTicks}
|
|
if (CurTicks < StartTicks) and
|
|
((CurTicks + MaxTicks) > ExpireTicks) then
|
|
Exit;
|
|
|
|
{If we get here, timer hasn't expired yet}
|
|
TimerExpired := False;
|
|
end;
|
|
end;
|
|
|
|
function ElapsedTime(ET : EventTimer) : Integer;
|
|
{-Returns elapsed time, in Ticks, for this timer}
|
|
var
|
|
CurTicks : Integer;
|
|
begin
|
|
with ET do begin
|
|
CurTicks := AdTimeGetTime div 55;
|
|
if CurTicks >= StartTicks then
|
|
{No wrap yet}
|
|
ElapsedTime := CurTicks - StartTicks
|
|
else
|
|
{Got a wrap, account for it}
|
|
ElapsedTime := (MaxTicks - StartTicks) + CurTicks;
|
|
end;
|
|
end;
|
|
|
|
function ElapsedTimeInSecs(ET : EventTimer) : Integer;
|
|
{-Returns elapsed time, in seconds, for this timer}
|
|
begin
|
|
ElapsedTimeInSecs := Ticks2Secs(ElapsedTime(ET));
|
|
end;
|
|
|
|
function RemainingTime(ET : EventTimer) : Integer;
|
|
{-Returns remaining time, in Ticks, for this timer}
|
|
var
|
|
CurTicks : Integer;
|
|
RemainingTicks : Integer;
|
|
begin
|
|
with ET do begin
|
|
CurTicks := AdTimeGetTime div 55;
|
|
if CurTicks >= StartTicks then
|
|
{No wrap yet}
|
|
RemainingTicks := ExpireTicks - CurTicks
|
|
else
|
|
{Got a wrap, account for it}
|
|
RemainingTicks := (ExpireTicks - MaxTicks) - CurTicks;
|
|
end;
|
|
if RemainingTicks < 0 then
|
|
RemainingTime := 0
|
|
else
|
|
RemainingTime := RemainingTicks;
|
|
end;
|
|
|
|
function RemainingTimeInSecs(ET : EventTimer) : Integer;
|
|
{-Returns remaining time, in seconds, for this timer}
|
|
begin
|
|
RemainingTimeInSecs := Ticks2Secs(RemainingTime(ET));
|
|
end;
|
|
|
|
function DelayTicks(Ticks : Integer; Yield : Bool) : Integer;
|
|
{-Delay for Ticks ticks}
|
|
var
|
|
ET : EventTimer;
|
|
Res : Integer;
|
|
begin
|
|
if Ticks <= 0 then begin
|
|
DelayTicks := 0;
|
|
Exit;
|
|
end else if Ticks > MaxTicks then
|
|
Ticks := MaxTicks;
|
|
|
|
Res := 0;
|
|
NewTimer(ET, Ticks);
|
|
repeat
|
|
if Yield then
|
|
Res := SafeYield;
|
|
until (Res = wm_Quit) or TimerExpired(ET);
|
|
DelayTicks := Res;
|
|
end;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function Long2StrZ(Dest : PChar; L : Integer) : PChar;
|
|
{-Convert a long/Cardinal/integer/byte/shortint to a string}
|
|
var
|
|
S : ShortString;
|
|
begin
|
|
Str(L, S);
|
|
Result := StrPCopy(Dest, string(S));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
const
|
|
MaxLen = 255;
|
|
ExtLen = 3;
|
|
|
|
type
|
|
TSmallArray = Array[0..MaxLen-1] of Char;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function Str2LongZ(S : PChar; var I : Integer) : Bool;
|
|
{-Convert a string to a Integer, returning true if successful}
|
|
var
|
|
Err : Integer;
|
|
begin
|
|
Val(StrPas(S),I,Err);
|
|
Result := Err = 0;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function JustPathnameZ(out Dest : string; PathName : string) : string;
|
|
{-Return just the drive:directory portion of a pathname}
|
|
begin
|
|
Result := ExtractFileDir(PathName);
|
|
Dest := Result;
|
|
end;
|
|
|
|
function JustPathnameZ(Dest : PAnsiChar; PathName : PAnsiChar) : PAnsiChar; overload;
|
|
{-Return just the drive:directory portion of a pathname}
|
|
var
|
|
I : Integer;
|
|
|
|
begin
|
|
I := AnsiStrings.StrLen(PathName);
|
|
repeat
|
|
Dec(I);
|
|
until (I = -1) or (PathName[I] in DosDelimSet);
|
|
|
|
if I = -1 then
|
|
{Had no drive or directory name}
|
|
Dest[0] := #0
|
|
else if I = 0 then begin
|
|
{Either the root directory of default drive or invalid pathname}
|
|
Dest[0] := PathName[0];
|
|
Dest[1] := #0;
|
|
end else if (PathName[I] = '\') then begin
|
|
if PathName[Pred(I)] = ':' then
|
|
{Root directory of a drive, leave trailing backslash}
|
|
Dest := StrStCopy(Dest, PathName, 0, Succ(I))
|
|
else
|
|
{Subdirectory, remove the trailing backslash}
|
|
Dest := StrStCopy(Dest, PathName, 0, I);
|
|
end else
|
|
{Either the default directory of a drive or invalid pathname}
|
|
Dest:= StrStCopy(Dest, PathName, 0, Succ(I));
|
|
Result := Dest;
|
|
end;
|
|
|
|
function JustFilenameZ(Dest : PAnsiChar; PathName : PAnsiChar) : PAnsiChar;
|
|
{-Return just the filename of a pathname}
|
|
var
|
|
I : Cardinal;
|
|
begin
|
|
I := AnsiStrings.StrLen(PathName);
|
|
while (I > 0) and (not (PathName[I-1] in DosDelimSet)) do
|
|
Dec(I);
|
|
Dest := StrStCopy(Dest, PathName, I, MaxLen);
|
|
Result := Dest;
|
|
end;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function JustExtensionZ(out Dest : string; Name : string) : string;
|
|
var
|
|
X : string;
|
|
begin
|
|
X := ExtractFileExt(Name);
|
|
if X = '' then
|
|
Dest := ''
|
|
else
|
|
Dest := Copy(X, 2, 255);
|
|
Result := Dest;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrStCopy(Dest : PAnsiChar; S : PAnsiChar; Pos, Count : Cardinal) : PAnsiChar;
|
|
var
|
|
Len : Cardinal;
|
|
|
|
begin
|
|
Len := AnsiStrings.StrLen(S);
|
|
if Pos < Len then begin
|
|
if (Len-Pos) < Count then
|
|
Count := Len-Pos;
|
|
Move(S[Pos], Dest^, Count);
|
|
Dest[Count] := #0;
|
|
end else
|
|
Dest[0] := #0;
|
|
Result := Dest;
|
|
end;
|
|
|
|
function StrStCopy(Dest : PWideChar; S : PWideChar; Pos, Count : Cardinal) : PWideChar;
|
|
var
|
|
Len : Cardinal;
|
|
begin
|
|
Len := StrLenW(S);
|
|
if Pos < Len then begin
|
|
if (Len-Pos) < Count then
|
|
Count := Len-Pos;
|
|
Move(S[Pos], Dest^, Count * SizeOf(WideChar));
|
|
Dest[Count] := #0;
|
|
end else
|
|
Dest[0] := #0;
|
|
StrStCopy := Dest;
|
|
end;
|
|
|
|
|
|
function AddBackSlashZ(out Dest : string; DirName : string) : string; overload;
|
|
{-Add a default backslash to a directory name}
|
|
begin
|
|
Result := IncludeTrailingPathDelimiter(DirName);
|
|
Dest := Result;
|
|
end;
|
|
|
|
function AddBackSlashZ(Dest : PAnsiChar; DirName : PAnsiChar) : PAnsiChar;
|
|
{-Add a default backslash to a directory name}
|
|
var
|
|
L : Cardinal;
|
|
begin
|
|
Result := Dest;
|
|
AnsiStrings.StrCopy(Dest, DirName);
|
|
L := AnsiStrings.StrLen(DirName);
|
|
if (L > 0) and not(DirName[L-1] in DosDelimSet) then begin
|
|
Dest[L] := '\';
|
|
Dest[L+1] := #0;
|
|
end;
|
|
end;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function ExistFileZ(FName : string) : Bool;
|
|
begin
|
|
Result := FileExists(FName);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function ForceExtensionZ(out Dest : string; Name, Ext : string) : string; overload;
|
|
begin
|
|
Result := ChangeFileExt(Name,'.'+Ext);
|
|
Dest := Result;
|
|
end;
|
|
|
|
function DefaultExtensionZ(out Dest : string; Name, Ext : string) : string;
|
|
var
|
|
S : string;
|
|
begin
|
|
S := Name;
|
|
if ExtractFileExt(S) = '' then
|
|
S := ChangeFileExt(S,'.'+Ext);
|
|
Dest := S;
|
|
Result := S;
|
|
end;
|
|
|
|
function GetPtr(P : Pointer; O : Integer) : Pointer; assembler; register;
|
|
asm
|
|
add eax,edx {eax = P; edx = Offset}
|
|
end;
|
|
|
|
procedure NotBuffer(var Buf; Len : Cardinal); assembler; register;
|
|
asm
|
|
{eax is the pointer to the buffer}
|
|
{edx is the length of the buffer}
|
|
xor ecx,ecx
|
|
shr edx,1
|
|
rcl ecx,1
|
|
shr edx,1
|
|
rcl ecx,1
|
|
|
|
or edx,edx
|
|
jz @2
|
|
|
|
@1: not dword ptr [eax]
|
|
add eax,4
|
|
dec edx
|
|
jnz @1
|
|
|
|
@2: or ecx,ecx
|
|
jz @4
|
|
|
|
@3: not byte ptr [eax]
|
|
inc eax
|
|
dec ecx
|
|
jnz @3
|
|
|
|
@4:
|
|
end;
|
|
|
|
function DelayMS(MS : Cardinal) : Cardinal;
|
|
var
|
|
CDelay: Cardinal;
|
|
CTime: Integer;
|
|
LTime: Integer;
|
|
begin
|
|
{Always return the delayed MS value}
|
|
DelayMS := MS;
|
|
|
|
{Get starting time}
|
|
LTime := AdTimeGetTime;
|
|
|
|
{Delay for MS milliseconds}
|
|
CDelay := 0;
|
|
while CDelay < MS do begin
|
|
CTime := AdTimeGetTime;
|
|
Inc(CDelay, CTime - LTime);
|
|
LTime := CTime;
|
|
end;
|
|
end;
|
|
|
|
{$IFNDEF PrnDrv}
|
|
function JustName(PathName : string) : string;
|
|
{-Return just the name (no extension, no path) of a pathname}
|
|
var
|
|
DotPos : Byte;
|
|
begin
|
|
PathName := ExtractFileName(PathName);
|
|
DotPos := Pos('.', PathName);
|
|
if DotPos > 0 then
|
|
PathName := Copy(PathName, 1, DotPos-1);
|
|
Result := PathName;
|
|
end;
|
|
|
|
function AddBackSlash(const DirName : String) : String;
|
|
begin
|
|
Result := IncludeTrailingPathDelimiter(DirName);
|
|
end;
|
|
|
|
function AddBackSlash(const DirName : AnsiString) : AnsiString;
|
|
begin
|
|
Result := AnsiString(IncludeTrailingPathDelimiter(string(DirName)));
|
|
end;
|
|
|
|
function IsWin2000 : Boolean;
|
|
//var
|
|
// Osi : TOSVersionInfo;
|
|
begin
|
|
// Result := False;
|
|
// Osi.dwOSVersionInfoSize := sizeof(Osi);
|
|
// GetVersionEx(Osi);
|
|
// if (Osi.dwPlatformID = Ver_Platform_Win32_NT) then
|
|
// if Osi.dwMinorVersion = 0 then {!!.04}
|
|
// Result := True; //SZ: was false on Windows XP, Win7
|
|
Result := CheckWin32Version(5, 0);
|
|
end;
|
|
|
|
function IsWinNT : Boolean;
|
|
var
|
|
Osi : TOSVersionInfo;
|
|
begin
|
|
Osi.dwOSVersionInfoSize := sizeof(Osi);
|
|
GetVersionEx(Osi);
|
|
Result := (Osi.dwPlatformID = Ver_Platform_Win32_NT);
|
|
end;
|
|
|
|
{ TApdBaseComponent }
|
|
function TApdBaseComponent.GetVersion : string;
|
|
begin
|
|
Result := ApVersionStr;
|
|
end;
|
|
|
|
procedure TApdBaseComponent.SetVersion(const Value : string);
|
|
begin
|
|
end;
|
|
|
|
{ TApdBaseWinControl }
|
|
function TApdBaseWinControl.GetVersion : string;
|
|
begin
|
|
Result := ApVersionStr;
|
|
end;
|
|
|
|
procedure TApdBaseWinControl.SetVersion(const Value : string);
|
|
begin
|
|
end;
|
|
|
|
{ TApdBaseOleControl }
|
|
function TApdBaseOleControl.GetVersion : string;
|
|
begin
|
|
Result := ApVersionStr;
|
|
end;
|
|
|
|
procedure TApdBaseOleControl.SetVersion(const Value : string);
|
|
begin
|
|
end;
|
|
|
|
{ TApdBaseGraphicControl }
|
|
function TApdBaseGraphicControl.GetVersion: string;
|
|
begin
|
|
Result := ApVersionStr;
|
|
end;
|
|
|
|
procedure TApdBaseGraphicControl.SetVersion(const Value: string);
|
|
begin
|
|
end;
|
|
|
|
{ TApdBaseScrollingWinControl }
|
|
function TApdBaseScrollingWinControl.GetVersion: string;
|
|
begin
|
|
Result := ApVersionStr;
|
|
end;
|
|
|
|
procedure TApdBaseScrollingWinControl.SetVersion(const Value: string);
|
|
begin
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function ApWinExecAndWait32(FileName : PChar; CommandLine : PChar;
|
|
Visibility : Integer) : Integer;
|
|
{ returns -1 if the Exec failed, otherwise returns the process' exit }
|
|
{ code when the process terminates }
|
|
var
|
|
CmdLine: string;
|
|
StartupInfo:TStartupInfo;
|
|
ProcessInfo:TProcessInformation;
|
|
Temp : DWORD;
|
|
begin
|
|
CmdLine := FileName;
|
|
if Assigned(CommandLine) then
|
|
CmdLine := CmdLine + ' ' + CommandLine;
|
|
FillChar(StartupInfo, Sizeof(StartupInfo),#0);
|
|
StartupInfo.cb := Sizeof(StartupInfo);
|
|
StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
|
|
StartupInfo.wShowWindow := Visibility;
|
|
if not CreateProcess(nil,
|
|
PChar(CmdLine), { pointer to command line string }
|
|
nil, { pointer to process security attributes }
|
|
nil, { pointer to thread security attributes }
|
|
false, { handle inheritance flag }
|
|
CREATE_NEW_CONSOLE or { creation flags }
|
|
NORMAL_PRIORITY_CLASS,
|
|
nil, { pointer to new environment block }
|
|
nil, { pointer to current directory name }
|
|
StartupInfo, { pointer to STARTUPINFO }
|
|
ProcessInfo) then { pointer to PROCESS_INF }
|
|
Result := -1
|
|
else begin
|
|
WaitforSingleObject(ProcessInfo.hProcess,INFINITE);
|
|
GetExitCodeProcess(ProcessInfo.hProcess,Temp);
|
|
CloseHandle(ProcessInfo.hProcess); {!!.02}
|
|
CloseHandle(ProcessInfo.hThread); {!!.02}
|
|
Result := Integer(Temp);
|
|
end;
|
|
end;
|
|
|
|
{ SZ - what is this???? removed because of Loader Lock problem FIXME
|
|
var // SWB
|
|
tc : TTimeCaps; // SWB
|
|
|
|
initialization
|
|
begin // SWB
|
|
timeGetDevCaps(@tc, SizeOf(tc)); // SWB
|
|
timeBeginPeriod(tc.wPeriodMin); // SWB
|
|
end; // SWB
|
|
|
|
finalization // SWB
|
|
begin // SWB
|
|
timeEndPeriod(tc.wPeriodMin); // SWB
|
|
end;
|
|
|
|
} // SWB
|
|
|
|
|
|
end.
|
|
|
|
|
|
|