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

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

#ifndef QiThreadTimersHPP
#define QiThreadTimersHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <QMenus.hpp>	// Pascal unit
#include <QiMath.hpp>	// Pascal unit
#include <QiGPFunctions.hpp>	// Pascal unit
#include <QiTypes.hpp>	// Pascal unit
#include <QExtCtrls.hpp>	// Pascal unit
#include <QStdCtrls.hpp>	// Pascal unit
#include <QComCtrls.hpp>	// Pascal unit
#include <QControls.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Types.hpp>	// Pascal unit
#include <QTypes.hpp>	// Pascal unit
#include <QClipbrd.hpp>	// Pascal unit
#include <QDialogs.hpp>	// Pascal unit
#include <QForms.hpp>	// Pascal unit
#include <QGraphics.hpp>	// Pascal unit
#include <Qt.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 Qithreadtimers
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TiThreadPriority { itpIdle, itpLowest, itpLower, itpNormal, itpHigher, itpHighest, itpTimeCritical };
#pragma option pop

#pragma option push -b-
enum TiThreadPolicy { itpSCHED_OTHER, itpSCHED_FIFO, itpSCHED_RR };
#pragma option pop

class DELPHICLASS TiTimerThread;
class PASCALIMPLEMENTATION TiTimerThread : public Classes::TThread 
{
	typedef Classes::TThread inherited;
	
private:
	int FPriorityLinux;
	TiThreadPolicy FPolicyLinux;
	
protected:
	void __fastcall SetPriorityWindows(const TiThreadPriority Value);
	void __fastcall SetPriorityLinux(const int Value);
	void __fastcall SetPolicyLinux(const TiThreadPolicy Value);
	TiThreadPriority __fastcall GetPriorityWindows(void);
	int __fastcall GetPriorityLinux(void);
	TiThreadPolicy __fastcall GetPolicyLinux(void);
	virtual void __fastcall Execute(void);
	void __fastcall DoEvent(void);
	
public:
	Classes::TComponent* Owner;
	Classes::TNotifyEvent OnTimer;
	int Interval;
	__property TiThreadPriority PriorityWindows = {read=GetPriorityWindows, write=SetPriorityWindows, nodefault};
	__property int PriorityLinux = {read=GetPriorityLinux, write=SetPriorityLinux, nodefault};
	__property TiThreadPolicy PolicyLinux = {read=GetPolicyLinux, write=SetPolicyLinux, nodefault};
	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 Qcontrols::TCustomControl 
{
	typedef Qcontrols::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();