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

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

#ifndef ahmtwaveholderHPP
#define ahmtwaveholderHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <MMSystem.hpp>	// Pascal unit
#include <ahmsystemclass.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

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

namespace Ahmtwaveholder
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TAHMExternalWave;
class DELPHICLASS TAHMWaveHolder;
class DELPHICLASS TAHMInternalWaves;
class DELPHICLASS TAHMInternalWave;
class PASCALIMPLEMENTATION TAHMInternalWaves : public Ahmsystemclass::TAHMCollection 
{
	typedef Ahmsystemclass::TAHMCollection inherited;
	
public:
	TAHMInternalWave* operator[](int Index) { return Items[Index]; }
	
private:
	TAHMWaveHolder* FAHMWaveHolder;
	TAHMInternalWave* __fastcall GetAHMInternalWave(int Index);
	void __fastcall SetAHMInternalWave(int Index, TAHMInternalWave* Value);
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TAHMInternalWaves(TAHMWaveHolder* AOwner);
	HIDESBASE TAHMInternalWave* __fastcall Add(void);
	HIDESBASE bool __fastcall Delete(int Index);
	__property TAHMInternalWave* Items[int Index] = {read=GetAHMInternalWave, write=SetAHMInternalWave/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAHMInternalWaves(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAHMExternalWaves;
class PASCALIMPLEMENTATION TAHMExternalWaves : public Ahmsystemclass::TAHMCollection 
{
	typedef Ahmsystemclass::TAHMCollection inherited;
	
public:
	TAHMExternalWave* operator[](int Index) { return Items[Index]; }
	
private:
	TAHMWaveHolder* FAHMWaveHolder;
	TAHMExternalWave* __fastcall GetAHMExternalWave(int Index);
	void __fastcall SetAHMExternalWave(int Index, TAHMExternalWave* Value);
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TAHMExternalWaves(TAHMWaveHolder* AOwner);
	HIDESBASE TAHMExternalWave* __fastcall Add(void);
	HIDESBASE bool __fastcall Delete(int Index);
	__property TAHMExternalWave* Items[int Index] = {read=GetAHMExternalWave, write=SetAHMExternalWave/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAHMExternalWaves(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TAHMWaveHolder : public Ahmsystemclass::TAHMSystemComponent 
{
	typedef Ahmsystemclass::TAHMSystemComponent inherited;
	
private:
	TAHMInternalWaves* FAHMInternalWaves;
	TAHMExternalWaves* FAHMExternalWaves;
	void __fastcall SetAHMExternalWaves(TAHMExternalWaves* Value);
	void __fastcall SetAHMInternalWaves(TAHMInternalWaves* Value);
	
public:
	__fastcall virtual TAHMWaveHolder(Classes::TComponent* AOwner);
	__fastcall virtual ~TAHMWaveHolder(void);
	bool __fastcall PlayInternal(int Index);
	bool __fastcall PlayExternal(int Index);
	void __fastcall StopSounds(void);
	
__published:
	__property TAHMInternalWaves* Internals = {read=FAHMInternalWaves, write=SetAHMInternalWaves};
	__property TAHMExternalWaves* Externals = {read=FAHMExternalWaves, write=SetAHMExternalWaves};
};


class PASCALIMPLEMENTATION TAHMExternalWave : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TAHMWaveHolder* FAHMWaveHolder;
	bool FLooped;
	bool FAsynchronous;
	AnsiString FFileName;
	void __fastcall SetAsynchronous(const bool Value);
	void __fastcall SetFileName(const AnsiString Value);
	void __fastcall SetLooped(const bool Value);
	
protected:
	virtual AnsiString __fastcall GetDisplayName();
	
public:
	bool __fastcall Play(void);
	__fastcall virtual TAHMExternalWave(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property TAHMWaveHolder* Owner = {read=FAHMWaveHolder};
	__property AnsiString DisplayName = {read=GetDisplayName};
	
__published:
	__property bool Asynchronous = {read=FAsynchronous, write=SetAsynchronous, default=1};
	__property bool Looped = {read=FLooped, write=SetLooped, default=0};
	__property AnsiString WavFileName = {read=FFileName, write=SetFileName};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TAHMExternalWave(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TAHMInternalWave : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	Classes::TMemoryStream* FWaveData;
	AnsiString FWave;
	TAHMWaveHolder* FAHMWaveHolder;
	bool FLooped;
	bool FAsynchronous;
	void __fastcall ReadData(Classes::TStream* Stream);
	void __fastcall WriteData(Classes::TStream* Stream);
	bool __fastcall Empty(void);
	void __fastcall SetWave(const AnsiString Value);
	void __fastcall SetLooped(const bool Value);
	void __fastcall SetAsynchronous(const bool Value);
	
protected:
	virtual AnsiString __fastcall GetDisplayName();
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	
public:
	void __fastcall Clear(void);
	void __fastcall LoadFromFile(AnsiString FileName);
	void __fastcall SaveToFile(AnsiString FileName);
	void __fastcall LoadFromStream(Classes::TStream* Stream);
	void __fastcall SaveToStream(Classes::TStream* Stream);
	__fastcall virtual TAHMInternalWave(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property TAHMWaveHolder* Owner = {read=FAHMWaveHolder};
	__property AnsiString DisplayName = {read=GetDisplayName};
	__fastcall virtual ~TAHMInternalWave(void);
	bool __fastcall Play(void);
	
__published:
	__property bool Asynchronous = {read=FAsynchronous, write=SetAsynchronous, default=1};
	__property bool Looped = {read=FLooped, write=SetLooped, nodefault};
	__property AnsiString Wave = {read=FWave, write=SetWave};
};


//-- var, const, procedure ---------------------------------------------------

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

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