commconnect.hpp

boomerang library 5.11 internet ed

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Commconnect.pas' rev: 10.00

#ifndef CommconnectHPP
#define CommconnectHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Connect.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Syncobjs.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Commconnect
{
//-- type declarations -------------------------------------------------------
typedef void __fastcall (__closure *TCommEvent)(System::TObject* Sender, unsigned Status);

#pragma option push -b-
enum TCommEventType { evBreak, evCts, evDsr, evError, evRing, evRlsd, evRxChar, evRxFlag, evTxEmpty };
#pragma option pop

typedef Set<TCommEventType, evBreak, evTxEmpty>  TCommEventTypes;

#pragma option push -b-
enum TBaudrate { br110, br300, br600, br1200, br2400, br4800, br9600, br14400, br19200, br38400, br56000, br57600, br115200, br128000, br256000 };
#pragma option pop

#pragma option push -b-
enum TParity { paNone, paOdd, paEven, paMark, paSpace };
#pragma option pop

#pragma option push -b-
enum TStopbits { sb10, sb15, sb20 };
#pragma option pop

#pragma option push -b-
enum TDatabits { da4, da5, da6, da7, da8 };
#pragma option pop

#pragma option push -b-
enum TFlowControl { fcNone, fcCTS, fcDTR, fcSoftware, fcDefault };
#pragma option pop

#pragma option push -b-
enum TCommOption { coParityCheck, coDsrSensitivity, coIgnoreXOff, coErrorChar, coNullStrip };
#pragma option pop

typedef Set<TCommOption, coParityCheck, coNullStrip>  TCommOptions;

typedef void __fastcall (__closure *TCommErrorEvent)(System::TObject* Sender, int Errors);

class DELPHICLASS TCommEventThread;
class DELPHICLASS TCommHandle;
class PASCALIMPLEMENTATION TCommHandle : public Connect::TCommunicationConnection 
{
	typedef Connect::TCommunicationConnection inherited;
	
private:
	unsigned FhCommDev;
	TBaudrate FBaudrate;
	TParity FParity;
	TStopbits FStopBits;
	TDatabits FDataBits;
	TFlowControl FFlowControl;
	TCommOptions FOptions;
	int FReadTimeout;
	int FWriteTimeout;
	int FReadBufSize;
	int FWriteBufSize;
	TCommEventTypes FMonitorEvents;
	char FEventChars[5];
	Syncobjs::TSimpleEvent* FEvent;
	Syncobjs::TCriticalSection* FCriticalSection;
	TCommEventThread* FEventThread;
	Classes::TNotifyEvent FOnBreak;
	Classes::TNotifyEvent FOnCts;
	Classes::TNotifyEvent FOnDsr;
	TCommErrorEvent FOnError;
	Classes::TNotifyEvent FOnRing;
	Classes::TNotifyEvent FOnRlsd;
	Classes::TNotifyEvent FOnRxFlag;
	Classes::TNotifyEvent FOnTxEmpty;
	void __fastcall SethCommDev(unsigned Value);
	void __fastcall SetBaudRate(TBaudrate Value);
	void __fastcall SetParity(TParity Value);
	void __fastcall SetStopbits(TStopbits Value);
	void __fastcall SetDatabits(TDatabits Value);
	void __fastcall SetOptions(TCommOptions Value);
	void __fastcall SetFlowControl(TFlowControl Value);
	char __fastcall GetEventChar(int Index);
	void __fastcall SetEventChar(int Index, char Value);
	void __fastcall SetReadBufSize(int Value);
	void __fastcall SetWriteBufSize(int Value);
	void __fastcall SetMonitorEvents(TCommEventTypes Value);
	bool __fastcall GetComState(int Index);
	bool __fastcall GetModemState(int Index);
	void __fastcall SetEsc(int Index, bool Value);
	void __fastcall UpdateCommTimeouts(void);
	void __fastcall UpdateDataControlBlock(void);
	
protected:
	virtual void __fastcall OpenConn(void);
	virtual void __fastcall CloseConn(void);
	virtual void __fastcall UpdateDCB(void);
	void __fastcall EscapeComm(int Flag);
	virtual void __fastcall HandleCommEvent(unsigned Status);
	virtual int __fastcall Write(void *Buf, int Count);
	virtual int __fastcall Read(void *Buf, int Count);
	
public:
	__fastcall virtual TCommHandle(Classes::TComponent* AOwner);
	__fastcall virtual ~TCommHandle(void);
	void __fastcall ComError2(const AnsiString aFunc);
	__property unsigned hCommDev = {read=FhCommDev, write=SethCommDev, nodefault};
	virtual int __fastcall InQueCount(void);
	int __fastcall OutQueCount(void);
	void __fastcall Lock(void);
	void __fastcall Unlock(void);
	virtual void __fastcall PurgeIn(void);
	virtual void __fastcall PurgeOut(void);
	__property bool CtsHold = {read=GetComState, index=0, nodefault};
	__property bool DsrHold = {read=GetComState, index=1, nodefault};
	__property bool RlsdHold = {read=GetComState, index=2, nodefault};
	__property bool XoffHold = {read=GetComState, index=3, nodefault};
	__property bool XOffSent = {read=GetComState, index=4, nodefault};
	__property bool Eof = {read=GetComState, index=5, nodefault};
	__property bool DTRState = {write=SetEsc, index=1, nodefault};
	__property bool RTSState = {write=SetEsc, index=2, nodefault};
	__property bool BreakState = {write=SetEsc, index=3, nodefault};
	__property bool XONState = {write=SetEsc, index=4, nodefault};
	__property bool CTS = {read=GetModemState, index=16, nodefault};
	__property bool DSR = {read=GetModemState, index=32, nodefault};
	__property bool RING = {read=GetModemState, index=64, nodefault};
	__property bool RLSD = {read=GetModemState, index=128, nodefault};
	
__published:
	__property TBaudrate Baudrate = {read=FBaudrate, write=SetBaudRate, default=6};
	__property TParity Parity = {read=FParity, write=SetParity, default=0};
	__property TStopbits Stopbits = {read=FStopBits, write=SetStopbits, default=0};
	__property TDatabits Databits = {read=FDataBits, write=SetDatabits, default=4};
	__property TCommOptions Options = {read=FOptions, write=SetOptions, nodefault};
	__property DontSynchronize ;
	__property TFlowControl FlowControl = {read=FFlowControl, write=SetFlowControl, default=4};
	__property char XonChar = {read=GetEventChar, write=SetEventChar, index=1, default=17};
	__property char XoffChar = {read=GetEventChar, write=SetEventChar, index=2, default=19};
	__property char ErrorChar = {read=GetEventChar, write=SetEventChar, index=3, default=0};
	__property char EofChar = {read=GetEventChar, write=SetEventChar, index=4, default=0};
	__property char EvtChar = {read=GetEventChar, write=SetEventChar, index=5, default=0};
	__property int ReadTimeout = {read=FReadTimeout, write=FReadTimeout, default=1000};
	__property int WriteTimeout = {read=FWriteTimeout, write=FWriteTimeout, default=1000};
	__property int ReadBufSize = {read=FReadBufSize, write=SetReadBufSize, default=4096};
	__property int WriteBufSize = {read=FWriteBufSize, write=SetWriteBufSize, default=2048};
	__property TCommEventTypes MonitorEvents = {read=FMonitorEvents, write=SetMonitorEvents, nodefault};
	__property Classes::TNotifyEvent OnBreak = {read=FOnBreak, write=FOnBreak};
	__property Classes::TNotifyEvent OnCts = {read=FOnCts, write=FOnCts};
	__property Classes::TNotifyEvent OnDsr = {read=FOnDsr, write=FOnDsr};
	__property Classes::TNotifyEvent OnRing = {read=FOnRing, write=FOnRing};
	__property Classes::TNotifyEvent OnRlsd = {read=FOnRlsd, write=FOnRlsd};
	__property TCommErrorEvent OnError = {read=FOnError, write=FOnError};
	__property OnRxChar ;
	__property Classes::TNotifyEvent OnRxFlag = {read=FOnRxFlag, write=FOnRxFlag};
	__property Classes::TNotifyEvent OnTxEmpty = {read=FOnTxEmpty, write=FOnTxEmpty};
};


class PASCALIMPLEMENTATION TCommEventThread : public Classes::TThread 
{
	typedef Classes::TThread inherited;
	
private:
	unsigned FCommHandle;
	unsigned FEventMask;
	TCommHandle* FComm;
	Syncobjs::TSimpleEvent* FEvent;
	
protected:
	virtual void __fastcall Execute(void);
	HIDESBASE void __fastcall Terminate(void);
	void __fastcall DoOnSignal(void);
	
public:
	__fastcall TCommEventThread(TCommHandle* aComm, unsigned Handle, TCommEventTypes Events);
	__fastcall virtual ~TCommEventThread(void);
};


class DELPHICLASS TComm;
class PASCALIMPLEMENTATION TComm : public TCommHandle 
{
	typedef TCommHandle inherited;
	
private:
	AnsiString FDeviceName;
	void __fastcall SetDeviceName(const AnsiString Value);
	
protected:
	virtual void __fastcall OpenConn(void);
	virtual void __fastcall CloseConn(void);
	
public:
	__fastcall virtual TComm(Classes::TComponent* AOwner);
	
__published:
	__property AnsiString DeviceName = {read=FDeviceName, write=SetDeviceName};
public:
	#pragma option push -w-inl
	/* TCommHandle.Destroy */ inline __fastcall virtual ~TComm(void) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TModemRxCommandEvent)(System::TObject* Sender, AnsiString aRx);

class DELPHICLASS TModem;
class PASCALIMPLEMENTATION TModem : public TComm 
{
	typedef TComm inherited;
	
private:
	Classes::TStrings* fCommands;
	int FDelayBeforeInit;
	int FDelayAfterInit;
	int FConnectTimeout;
	int FResponseTimeout;
	AnsiString fReceivedBuffer;
	Syncobjs::TSimpleEvent* FCommandEvent;
	bool fCapturing;
	bool fIsMakingCall;
	bool fCancel;
	TModemRxCommandEvent FOnRxCommand;
	AnsiString __fastcall GetCommand(int Index);
	void __fastcall SetCommand(int Index, AnsiString Value);
	bool __fastcall SendAndReceive(AnsiString aSend, AnsiString * aResponses, const int aResponses_Size, int aTimeout, int &aRespCode);
	
protected:
	virtual void __fastcall OpenConn(void);
	virtual void __fastcall CloseConn(void);
	virtual void __fastcall DoOnRxChar(int Count);
	
public:
	__property bool IsMakingCall = {read=fIsMakingCall, nodefault};
	__fastcall virtual TModem(Classes::TComponent* aOwner);
	__fastcall virtual ~TModem(void);
	void __fastcall Drop(void);
	
__published:
	__property AnsiString cInit = {read=GetCommand, write=SetCommand, index=0};
	__property int DelayBeforeInit = {read=FDelayBeforeInit, write=FDelayBeforeInit, nodefault};
	__property int DelayAfterInit = {read=FDelayAfterInit, write=FDelayAfterInit, nodefault};
	__property int ResponseTimeout = {read=FResponseTimeout, write=FResponseTimeout, nodefault};
	__property int ConnectTimeout = {read=FConnectTimeout, write=FConnectTimeout, nodefault};
	__property AnsiString rInit = {read=GetCommand, write=SetCommand, index=1};
	__property AnsiString cDial = {read=GetCommand, write=SetCommand, index=2};
	__property AnsiString rConnect = {read=GetCommand, write=SetCommand, index=3};
	__property AnsiString rBusy = {read=GetCommand, write=SetCommand, index=4};
	__property AnsiString rNoCarrier = {read=GetCommand, write=SetCommand, index=5};
	__property AnsiString rNoDialtone = {read=GetCommand, write=SetCommand, index=6};
	__property AnsiString cHangUp = {read=GetCommand, write=SetCommand, index=7};
	__property AnsiString rHangUp = {read=GetCommand, write=SetCommand, index=8};
	__property AnsiString PhoneNumber = {read=GetCommand, write=SetCommand, index=9};
	__property TModemRxCommandEvent OnRxCommand = {read=FOnRxCommand, write=FOnRxCommand};
};


class DELPHICLASS EComError;
class PASCALIMPLEMENTATION EComError : public Connect::EConnectError 
{
	typedef Connect::EConnectError inherited;
	
public:
	#pragma option push -w-inl
	/* Exception.Create */ inline __fastcall EComError(const AnsiString Msg) : Connect::EConnectError(Msg) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall EComError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size) : Connect::EConnectError(Msg, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateRes */ inline __fastcall EComError(int Ident)/* overload */ : Connect::EConnectError(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall EComError(int Ident, System::TVarRec const * Args, const int Args_Size)/* overload */ : Connect::EConnectError(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall EComError(const AnsiString Msg, int AHelpContext) : Connect::EConnectError(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall EComError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size, int AHelpContext) : Connect::EConnectError(Msg, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall EComError(int Ident, int AHelpContext)/* overload */ : Connect::EConnectError(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall EComError(System::PResStringRec ResStringRec, System::TVarRec const * Args, const int Args_Size, int AHelpContext)/* overload */ : Connect::EConnectError(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~EComError(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE Syncobjs::TWaitResult __fastcall Event_WaitFor(Syncobjs::TEvent* fEvent, unsigned aTimeout);
extern PACKAGE bool __fastcall Int2BaudRate(int BR1, TBaudrate &BR);
extern PACKAGE int __fastcall BaudRate2Int(TBaudrate BR);
extern PACKAGE void __fastcall Register(void);

}	/* namespace Commconnect */
using namespace Commconnect;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Commconnect