vrhptimerfunc.hpp

wimax bs simulator对应的GUI程序

// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'VrHPTimerFunc.pas' rev: 5.00

#ifndef VrHPTimerFuncHPP
#define VrHPTimerFuncHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <VrControls.hpp>	// Pascal unit
#include <VrHPTimer.hpp>	// Pascal unit
#include <Registry.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Vrhptimerfunc
{
//-- type declarations -------------------------------------------------------
typedef int TVrHPTimerARRAY[4];

struct TLargeInteger
{
	
	union
	{
		struct 
		{
			__int64 QuadPart;
			
		};
		struct 
		{
			unsigned Lowpart;
			int HighPart;
			
		};
		
	};
} ;

typedef void __fastcall (__closure *TOnHPTimer)(Extended Seconds, Extended Delta, __int64 N);

class DELPHICLASS TVrHPCustomTimer;
class DELPHICLASS TVrHPTimeBase;
class PASCALIMPLEMENTATION TVrHPTimeBase : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	double FTicksPerSecond;
	int FProcessorType;
	int FFamily;
	int FModel;
	int FStepping;
	System::Comp FCPUSpeed;
	double FCPUSpeedMhz;
	double FExactCPUSpeed;
	bool FIDAvailable;
	int FId1;
	int FId2;
	int FId3;
	int FId4;
	bool FHasFPU;
	bool FHasTimeStamp;
	bool FSupportsTimeStamp;
	bool FHasAPIC;
	Word FTimeStamp1;
	Word FTimeStamp2;
	Word FTimeStamp3;
	Word FTimeStamp4;
	bool __fastcall GetIDInfo(void);
	void __fastcall RefreshTimeStamp(void);
	System::Comp __fastcall GetCPUSpeed(void);
	System::Comp __fastcall GetTicksPerSecond(Word ITERATIONS, double &TPS);
	System::Comp __fastcall RegGetCPUSpeed(void);
	TLargeInteger __fastcall GetTimeStamp(void);
	System::Comp __fastcall GetElapsedTicks(const TLargeInteger &FStartTime);
	bool __fastcall GetSupportsTimeStamp(void);
	void __fastcall SetReadOnlyDouble(const double Value);
	void __fastcall SetReadOnlyBool(const bool Value);
	void __fastcall SetReadOnlyLongInt(const int Value);
	
public:
	__fastcall virtual TVrHPTimeBase(Classes::TComponent* AOwner);
	void __fastcall StartTimer(void);
	void __fastcall StopTimer(void);
	
__published:
	__property int ProcessorType = {read=FProcessorType, write=SetReadOnlyLongInt, stored=false, nodefault
		};
	__property int Family = {read=FFamily, write=SetReadOnlyLongInt, stored=false, nodefault};
	__property int Model = {read=FModel, write=SetReadOnlyLongInt, stored=false, nodefault};
	__property int Stepping = {read=FStepping, write=SetReadOnlyLongInt, stored=false, nodefault};
	__property double CPUSpeedMhz = {read=FCPUSpeedMhz, write=SetReadOnlyDouble, stored=false};
	__property bool IDAvailable = {read=FIDAvailable, write=SetReadOnlyBool, stored=false, nodefault};
	__property bool SupportTimeStamp = {read=FSupportsTimeStamp, write=SetReadOnlyBool, stored=false, nodefault
		};
	__property bool HasTimeStamp = {read=FHasTimeStamp, write=SetReadOnlyBool, stored=false, nodefault}
		;
public:
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TVrHPTimeBase(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TVrHPCustomTimer : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Vrhptimer::THPTimerThread* HPThread;
	TVrHPTimeBase* FHPTimeBase;
	double FTicksPerSecond;
	TLargeInteger FStartTime;
	TLargeInteger FEndTime;
	TLargeInteger FElapsed;
	Classes::TThreadPriority FThreadPriority;
	bool FEnabled;
	AnsiString FVersion;
	void __fastcall SetThreadPriority(const Classes::TThreadPriority Value);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetVersion(const AnsiString Value);
	void __fastcall SetHPTimeBase(const TVrHPTimeBase* Value);
	
protected:
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation AOperation
		);
	
public:
	__fastcall virtual TVrHPCustomTimer(Classes::TComponent* AOwner);
	__fastcall virtual ~TVrHPCustomTimer(void);
	double __fastcall GetElapsedSeconds(void);
	void __fastcall StartTimer(void);
	void __fastcall StopTimer(void);
	virtual void __fastcall Trigger(Extended Seconds, Extended Delta, __int64 N);
	
__published:
	__property bool Enabled = {read=FEnabled, write=SetEnabled, nodefault};
	__property TVrHPTimeBase* HPTimeBase = {read=FHPTimeBase, write=SetHPTimeBase};
	__property Classes::TThreadPriority ThreadPriority = {read=FThreadPriority, write=SetThreadPriority
		, default=3};
	__property AnsiString Version = {read=FVersion, write=SetVersion};
};


class DELPHICLASS TVrHPTimer;
class PASCALIMPLEMENTATION TVrHPTimer : public TVrHPCustomTimer 
{
	typedef TVrHPCustomTimer inherited;
	
private:
	Extended FFrequency;
	Extended FTimePeriod;
	TOnHPTimer FOnHighPrecisionTimer;
	void __fastcall SetFrequency(const Extended Value);
	void __fastcall SetTimePeriod(const Extended Value);
	void __fastcall SetOnHighPrecisionTimer(const TOnHPTimer Value);
	
public:
	__fastcall virtual TVrHPTimer(Classes::TComponent* AOwner);
	__fastcall virtual ~TVrHPTimer(void);
	virtual void __fastcall Trigger(Extended Seconds, Extended Delta, __int64 N);
	
__published:
	__property Extended Frequency = {read=FFrequency, write=SetFrequency};
	__property Extended TimePeriod = {read=FTimePeriod, write=SetTimePeriod};
	__property TOnHPTimer OnHighPrecisionTimer = {read=FOnHighPrecisionTimer, write=SetOnHighPrecisionTimer
		};
};


class DELPHICLASS TVrHPDelay;
class PASCALIMPLEMENTATION TVrHPDelay : public TVrHPCustomTimer 
{
	typedef TVrHPCustomTimer inherited;
	
private:
	Extended FDelay;
	TOnHPTimer FOnHighPrecisionDelay;
	void __fastcall SetDelay(const Extended Value);
	void __fastcall SetOnHighPrecisionDelay(const TOnHPTimer Value);
	
public:
	__fastcall virtual TVrHPDelay(Classes::TComponent* AOwner);
	__fastcall virtual ~TVrHPDelay(void);
	virtual void __fastcall Trigger(Extended Seconds, Extended Delta, __int64 N);
	
__published:
	__property Extended Delay = {read=FDelay, write=SetDelay};
	__property TOnHPTimer OnHighPrecisionDelay = {read=FOnHighPrecisionDelay, write=SetOnHighPrecisionDelay
		};
};


//-- var, const, procedure ---------------------------------------------------
static const int ID_BIT = 0x200000;
extern PACKAGE System::Comp __fastcall OldGetCpuSpeed(void);
extern PACKAGE bool __fastcall IsHPTimer_Available(void);
extern PACKAGE int __fastcall GeTVrHPTimer(void);
extern PACKAGE unsigned __fastcall GetTimeStampHi(void);
extern PACKAGE unsigned __fastcall GetTimeStampLo(void);

}	/* namespace Vrhptimerfunc */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Vrhptimerfunc;
#endif
#pragma option pop	// -w-
#pragma option pop	// -Vx

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