cport.hpp

TComPort 4.0 delphi中com免DLL控件

// CodeGear C++Builder
// Copyright (c) 1995, 2007 by CodeGear
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Cport.pas' rev: 11.00

#ifndef CportHPP
#define CportHPP

#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 <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Inifiles.hpp>	// Pascal unit
#include <Registry.hpp>	// Pascal unit
#include <Cporttypes.hpp>	// Pascal unit

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

namespace Cport
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TComLink;
class PASCALIMPLEMENTATION TComLink : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Cporttypes::TComSignalEvent FOnConn;
	Cporttypes::TRxBufEvent FOnRxBuf;
	Cporttypes::TRxBufEvent FOnTxBuf;
	Classes::TNotifyEvent FOnTxEmpty;
	Classes::TNotifyEvent FOnRxFlag;
	Cporttypes::TComSignalEvent FOnCTSChange;
	Cporttypes::TComSignalEvent FOnDSRChange;
	Cporttypes::TComSignalEvent FOnRLSDChange;
	Classes::TNotifyEvent FOnRing;
	Cporttypes::TComSignalEvent FOnTx;
	Cporttypes::TComSignalEvent FOnRx;
	
public:
	__property Cporttypes::TComSignalEvent OnConn = {read=FOnConn, write=FOnConn};
	__property Cporttypes::TRxBufEvent OnRxBuf = {read=FOnRxBuf, write=FOnRxBuf};
	__property Cporttypes::TRxBufEvent OnTxBuf = {read=FOnTxBuf, write=FOnTxBuf};
	__property Classes::TNotifyEvent OnTxEmpty = {read=FOnTxEmpty, write=FOnTxEmpty};
	__property Classes::TNotifyEvent OnRxFlag = {read=FOnRxFlag, write=FOnRxFlag};
	__property Cporttypes::TComSignalEvent OnCTSChange = {read=FOnCTSChange, write=FOnCTSChange};
	__property Cporttypes::TComSignalEvent OnDSRChange = {read=FOnDSRChange, write=FOnDSRChange};
	__property Cporttypes::TComSignalEvent OnRLSDChange = {read=FOnRLSDChange, write=FOnRLSDChange};
	__property Classes::TNotifyEvent OnRing = {read=FOnRing, write=FOnRing};
	__property Cporttypes::TComSignalEvent OnTx = {read=FOnTx, write=FOnTx};
	__property Cporttypes::TComSignalEvent OnRx = {read=FOnRx, write=FOnRx};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TComLink(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TComLink(void) { }
	#pragma option pop
	
};


class DELPHICLASS TComThread;
class DELPHICLASS TCustomComPort;
class DELPHICLASS TComBuffer;
class PASCALIMPLEMENTATION TComBuffer : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TCustomComPort* FComPort;
	int FInputSize;
	int FOutputSize;
	void __fastcall SetComPort(const TCustomComPort* AComPort);
	void __fastcall SetInputSize(const int Value);
	void __fastcall SetOutputSize(const int Value);
	
protected:
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall TComBuffer(void);
	__property TCustomComPort* ComPort = {read=FComPort};
	
__published:
	__property int InputSize = {read=FInputSize, write=SetInputSize, default=1024};
	__property int OutputSize = {read=FOutputSize, write=SetOutputSize, default=1024};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TComBuffer(void) { }
	#pragma option pop
	
};


class DELPHICLASS TComParity;
class PASCALIMPLEMENTATION TComParity : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TCustomComPort* FComPort;
	Cporttypes::TParityBits FBits;
	bool FCheck;
	bool FReplace;
	char FReplaceChar;
	void __fastcall SetComPort(const TCustomComPort* AComPort);
	void __fastcall SetBits(const Cporttypes::TParityBits Value);
	void __fastcall SetCheck(const bool Value);
	void __fastcall SetReplace(const bool Value);
	void __fastcall SetReplaceChar(const char Value);
	
protected:
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall TComParity(void);
	__property TCustomComPort* ComPort = {read=FComPort};
	
__published:
	__property Cporttypes::TParityBits Bits = {read=FBits, write=SetBits, nodefault};
	__property bool Check = {read=FCheck, write=SetCheck, default=0};
	__property bool Replace = {read=FReplace, write=SetReplace, default=0};
	__property char ReplaceChar = {read=FReplaceChar, write=SetReplaceChar, default=0};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TComParity(void) { }
	#pragma option pop
	
};


class DELPHICLASS TComTimeouts;
class PASCALIMPLEMENTATION TComTimeouts : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TCustomComPort* FComPort;
	int FReadInterval;
	int FReadTotalM;
	int FReadTotalC;
	int FWriteTotalM;
	int FWriteTotalC;
	void __fastcall SetComPort(const TCustomComPort* AComPort);
	void __fastcall SetReadInterval(const int Value);
	void __fastcall SetReadTotalM(const int Value);
	void __fastcall SetReadTotalC(const int Value);
	void __fastcall SetWriteTotalM(const int Value);
	void __fastcall SetWriteTotalC(const int Value);
	
protected:
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall TComTimeouts(void);
	__property TCustomComPort* ComPort = {read=FComPort};
	
__published:
	__property int ReadInterval = {read=FReadInterval, write=SetReadInterval, default=-1};
	__property int ReadTotalMultiplier = {read=FReadTotalM, write=SetReadTotalM, default=0};
	__property int ReadTotalConstant = {read=FReadTotalC, write=SetReadTotalC, default=0};
	__property int WriteTotalMultiplier = {read=FWriteTotalM, write=SetWriteTotalM, default=100};
	__property int WriteTotalConstant = {read=FWriteTotalC, write=SetWriteTotalC, default=1000};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TComTimeouts(void) { }
	#pragma option pop
	
};


class DELPHICLASS TComFlowControl;
class PASCALIMPLEMENTATION TComFlowControl : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TCustomComPort* FComPort;
	bool FOutCTSFlow;
	bool FOutDSRFlow;
	Cporttypes::TDTRFlowControl FControlDTR;
	Cporttypes::TRTSFlowControl FControlRTS;
	bool FXonXoffOut;
	bool FXonXoffIn;
	bool FDSRSensitivity;
	bool FTxContinueOnXoff;
	char FXonChar;
	char FXoffChar;
	void __fastcall SetComPort(const TCustomComPort* AComPort);
	void __fastcall SetOutCTSFlow(const bool Value);
	void __fastcall SetOutDSRFlow(const bool Value);
	void __fastcall SetControlDTR(const Cporttypes::TDTRFlowControl Value);
	void __fastcall SetControlRTS(const Cporttypes::TRTSFlowControl Value);
	void __fastcall SetXonXoffOut(const bool Value);
	void __fastcall SetXonXoffIn(const bool Value);
	void __fastcall SetDSRSensitivity(const bool Value);
	void __fastcall SetTxContinueOnXoff(const bool Value);
	void __fastcall SetXonChar(const char Value);
	void __fastcall SetXoffChar(const char Value);
	void __fastcall SetFlowControl(const Cporttypes::TFlowControl Value);
	Cporttypes::TFlowControl __fastcall GetFlowControl(void);
	
protected:
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall TComFlowControl(void);
	__property TCustomComPort* ComPort = {read=FComPort};
	
__published:
	__property Cporttypes::TFlowControl FlowControl = {read=GetFlowControl, write=SetFlowControl, stored=false, nodefault};
	__property bool OutCTSFlow = {read=FOutCTSFlow, write=SetOutCTSFlow, nodefault};
	__property bool OutDSRFlow = {read=FOutDSRFlow, write=SetOutDSRFlow, nodefault};
	__property Cporttypes::TDTRFlowControl ControlDTR = {read=FControlDTR, write=SetControlDTR, nodefault};
	__property Cporttypes::TRTSFlowControl ControlRTS = {read=FControlRTS, write=SetControlRTS, nodefault};
	__property bool XonXoffOut = {read=FXonXoffOut, write=SetXonXoffOut, nodefault};
	__property bool XonXoffIn = {read=FXonXoffIn, write=SetXonXoffIn, nodefault};
	__property bool DSRSensitivity = {read=FDSRSensitivity, write=SetDSRSensitivity, default=0};
	__property bool TxContinueOnXoff = {read=FTxContinueOnXoff, write=SetTxContinueOnXoff, default=0};
	__property char XonChar = {read=FXonChar, write=SetXonChar, default=17};
	__property char XoffChar = {read=FXoffChar, write=SetXoffChar, default=19};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TComFlowControl(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TCustomComPort : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private: