ithreadtimers.hpp

Iocomp Ultra Pack v3.0.2 Sources.For.Delphi 数据显示编程插件,可用于工业控制

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

// (DO NOT EDIT: machine generated header) 'iThreadTimers.pas' rev: 6.00

#ifndef iThreadTimersHPP
#define iThreadTimersHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <Menus.hpp>	// Pascal unit
#include <iMath.hpp>	// Pascal unit
#include <iGPFunctions.hpp>	// Pascal unit
#include <iTypes.hpp>	// Pascal unit
#include <ExtCtrls.hpp>	// Pascal unit
#include <StdCtrls.hpp>	// Pascal unit
#include <ComCtrls.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Types.hpp>	// Pascal unit
#include <Clipbrd.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <TypInfo.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 Ithreadtimers
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TiTimerThread;
class PASCALIMPLEMENTATION TiTimerThread : public Classes::TThread 
{
	typedef Classes::TThread inherited;
	
private:
	HWND WindowHandle;
	
protected:
	virtual void __fastcall Execute(void);
	void __fastcall MessageMethod(Messages::TMessage &Message);
	void __fastcall DoEvent(void);
	
public:
	Classes::TComponent* Owner;
	Classes::TNotifyEvent OnTimer;
	int Interval;
	virtual void __fastcall AfterConstruction(void);
	__fastcall virtual ~TiTimerThread(void);
public:
	#pragma option push -w-inl
	/* TThread.Create */ inline __fastcall TiTimerThread(bool CreateSuspended) : Classes::TThread(CreateSuspended) { }
	#pragma option pop
	
};


class DELPHICLASS TiThreadTimers;
class PASCALIMPLEMENTATION TiThreadTimers : public Controls::TCustomControl 
{
	typedef Controls::TCustomControl inherited;
	
private:
	TiTimerThread* FTimer1;
	TiTimerThread* FTimer2;
	TiTimerThread* FTimer3;
	TiTimerThread* FTimer4;
	TiTimerThread* FTimer5;
	TiTimerThread* FTimer6;
	TiTimerThread* FTimer7;
	TiTimerThread* FTimer8;
	TiTimerThread* FTimer9;
	bool FEnabled1;
	bool FEnabled2;
	bool FEnabled3;
	bool FEnabled4;
	bool FEnabled5;
	bool FEnabled6;
	bool FEnabled7;
	bool FEnabled8;
	bool FEnabled9;
	void __fastcall SetEnabled1(const bool Value);
	void __fastcall SetEnabled2(const bool Value);
	void __fastcall SetEnabled3(const bool Value);
	void __fastcall SetEnabled4(const bool Value);
	void __fastcall SetEnabled5(const bool Value);
	void __fastcall SetEnabled6(const bool Value);
	void __fastcall SetEnabled7(const bool Value);
	void __fastcall SetEnabled8(const bool Value);
	void __fastcall SetEnabled9(const bool Value);
	void __fastcall SetInterval1(const int Value);
	void __fastcall SetInterval2(const int Value);
	void __fastcall SetInterval3(const int Value);
	void __fastcall SetInterval4(const int Value);
	void __fastcall SetInterval5(const int Value);
	void __fastcall SetInterval6(const int Value);
	void __fastcall SetInterval7(const int Value);
	void __fastcall SetInterval8(const int Value);
	void __fastcall SetInterval9(const int Value);
	int __fastcall GetInterval1(void);
	int __fastcall GetInterval2(void);
	int __fastcall GetInterval3(void);
	int __fastcall GetInterval4(void);
	int __fastcall GetInterval5(void);
	int __fastcall GetInterval6(void);
	int __fastcall GetInterval7(void);
	int __fastcall GetInterval8(void);
	int __fastcall GetInterval9(void);
	void __fastcall SetOnTimer1(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer2(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer3(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer4(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer5(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer6(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer7(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer8(const Classes::TNotifyEvent Value);
	void __fastcall SetOnTimer9(const Classes::TNotifyEvent Value);
	Classes::TNotifyEvent __fastcall GetOnTimer1();
	Classes::TNotifyEvent __fastcall GetOnTimer2();
	Classes::TNotifyEvent __fastcall GetOnTimer3();
	Classes::TNotifyEvent __fastcall GetOnTimer4();
	Classes::TNotifyEvent __fastcall GetOnTimer5();
	Classes::TNotifyEvent __fastcall GetOnTimer6();
	Classes::TNotifyEvent __fastcall GetOnTimer7();
	Classes::TNotifyEvent __fastcall GetOnTimer8();
	Classes::TNotifyEvent __fastcall GetOnTimer9();
	void __fastcall SetThreadPriority1(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority2(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority3(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority4(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority5(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority6(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority7(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority8(const Classes::TThreadPriority Value);
	void __fastcall SetThreadPriority9(const Classes::TThreadPriority Value);
	Classes::TThreadPriority __fastcall GetThreadPriority1(void);
	Classes::TThreadPriority __fastcall GetThreadPriority2(void);
	Classes::TThreadPriority __fastcall GetThreadPriority3(void);
	Classes::TThreadPriority __fastcall GetThreadPriority4(void);
	Classes::TThreadPriority __fastcall GetThreadPriority5(void);
	Classes::TThreadPriority __fastcall GetThreadPriority6(void);
	Classes::TThreadPriority __fastcall GetThreadPriority7(void);
	Classes::TThreadPriority __fastcall GetThreadPriority8(void);
	Classes::TThreadPriority __fastcall GetThreadPriority9(void);
	
protected:
	virtual void __fastcall Paint(void);
	void __fastcall DestroyTimer(TiTimerThread* &ATimer);
	TiTimerThread* __fastcall CreateTimer(int Interval, Classes::TNotifyEvent AOnTimer);
	
public:
	__fastcall virtual TiThreadTimers(Classes::TComponent* AOwner);
	__fastcall virtual ~TiThreadTimers(void);
	virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
	__property OnDblClick ;
	
__published:
	__property bool Enabled1 = {read=FEnabled1, write=SetEnabled1, default=0};
	__property bool Enabled2 = {read=FEnabled2, write=SetEnabled2, default=0};
	__property bool Enabled3 = {read=FEnabled3, write=SetEnabled3, default=0};
	__property bool Enabled4 = {read=FEnabled4, write=SetEnabled4, default=0};
	__property bool Enabled5 = {read=FEnabled5, write=SetEnabled5, default=0};
	__property bool Enabled6 = {read=FEnabled6, write=SetEnabled6, default=0};
	__property bool Enabled7 = {read=FEnabled7, write=SetEnabled7, default=0};
	__property bool Enabled8 = {read=FEnabled8, write=SetEnabled8, default=0};
	__property bool Enabled9 = {read=FEnabled9, write=SetEnabled9, default=0};
	__property int Interval1 = {read=GetInterval1, write=SetInterval1, default=1000};
	__property int Interval2 = {read=GetInterval2, write=SetInterval2, default=1000};
	__property int Interval3 = {read=GetInterval3, write=SetInterval3, default=1000};
	__property int Interval4 = {read=GetInterval4, write=SetInterval4, default=1000};
	__property int Interval5 = {read=GetInterval5, write=SetInterval5, default=1000};
	__property int Interval6 = {read=GetInterval6, write=SetInterval6, default=1000};
	__property int Interval7 = {read=GetInterval7, write=SetInterval7, default=1000};
	__property int Interval8 = {read=GetInterval8, write=SetInterval8, default=1000};
	__property int Interval9 = {read=GetInterval9, write=SetInterval9, default=1000};
	__property Classes::TThreadPriority ThreadPriority1 = {read=GetThreadPriority1, write=SetThreadPriority1, default=3};
	__property Classes::TThreadPriority ThreadPriority2 = {read=GetThreadPriority2, write=SetThreadPriority2, default=3};
	__property Classes::TThreadPriority ThreadPriority3 = {read=GetThreadPriority3, write=SetThreadPriority3, default=3};
	__property Classes::TThreadPriority ThreadPriority4 = {read=GetThreadPriority4, write=SetThreadPriority4, default=3};
	__property Classes::TThreadPriority ThreadPriority5 = {read=GetThreadPriority5, write=SetThreadPriority5, default=3};
	__property Classes::TThreadPriority ThreadPriority6 = {read=GetThreadPriority6, write=SetThreadPriority6, default=3};
	__property Classes::TThreadPriority ThreadPriority7 = {read=GetThreadPriority7, write=SetThreadPriority7, default=3};
	__property Classes::TThreadPriority ThreadPriority8 = {read=GetThreadPriority8, write=SetThreadPriority8, default=3};
	__property Classes::TThreadPriority ThreadPriority9 = {read=GetThreadPriority9, write=SetThreadPriority9, default=3};
	__property Classes::TNotifyEvent OnTimer1 = {read=GetOnTimer1, write=SetOnTimer1};
	__property Classes::TNotifyEvent OnTimer2 = {read=GetOnTimer2, write=SetOnTimer2};
	__property Classes::TNotifyEvent OnTimer3 = {read=GetOnTimer3, write=SetOnTimer3};
	__property Classes::TNotifyEvent OnTimer4 = {read=GetOnTimer4, write=SetOnTimer4};
	__property Classes::TNotifyEvent OnTimer5 = {read=GetOnTimer5, write=SetOnTimer5};
	__property Classes::TNotifyEvent OnTimer6 = {read=GetOnTimer6, write=SetOnTimer6};
	__property Classes::TNotifyEvent OnTimer7 = {read=GetOnTimer7, write=SetOnTimer7};
	__property Classes::TNotifyEvent OnTimer8 = {read=GetOnTimer8, write=SetOnTimer8};
	__property Classes::TNotifyEvent OnTimer9 = {read=GetOnTimer9, write=SetOnTimer9};
	__property Visible  = {default=0};
	__property Width  = {default=28};
	__property Height  = {default=28};
	__property PopupMenu ;
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TiThreadTimers(HWND ParentWindow) : Controls::TCustomControl(ParentWindow) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
static const Word WM_ITHREADTIMERMSG = 0x464;

}	/* namespace Ithreadtimers */
using namespace Ithreadtimers;
#pragma option pop	// -w-
#pragma option pop	// -Vx

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