xsms.hpp

boomerang library 5.11 internet ed

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

// (DO NOT EDIT: machine generated header) 'Xsms.pas' rev: 10.00

#ifndef XsmsHPP
#define XsmsHPP

#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 <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Gsm.hpp>	// Pascal unit
#include <Contnrs.hpp>	// Pascal unit
#include <Connect.hpp>	// Pascal unit

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

namespace Xsms
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TSMSProtocolStatus { smspsEmpty, smspsOK, smspsNotComplete };
#pragma option pop

#pragma option push -b-
enum TSMSProtocolInsertStatus { smsprOK, smsprBadFragment, smsprFragmentDoesNotFit, smsprFragmentDifferentData };
#pragma option pop

#pragma option push -b-
enum TSMSProtocolOptions { smspoAddressing, smspoReference };
#pragma option pop

typedef Set<TSMSProtocolOptions, smspoAddressing, smspoReference>  TSMSProtocolOptionsSet;

class DELPHICLASS TSMSProtocol;
class PASCALIMPLEMENTATION TSMSProtocol : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	AnsiString fData;
	Classes::TStrings* fFragments;
	TSMSProtocolStatus fStatus;
	int fReference;
	System::TDateTime fStamp;
	AnsiString __fastcall GetFragment(int Index);
	int __fastcall GetFragmentCount(void);
	AnsiString __fastcall GetData();
	void __fastcall SetData(const AnsiString Value);
	void __fastcall SetReference(const int Value);
	int __fastcall GetInsertedCount(void);
	
protected:
	int fLastInserted;
	virtual void __fastcall EncodeFragments(void) = 0 ;
	void __fastcall CheckCompleted(void);
	void __fastcall SetStamp(void);
	
public:
	__fastcall virtual TSMSProtocol(void);
	__fastcall virtual ~TSMSProtocol(void);
	virtual void __fastcall Clear(void);
	__property int FragmentCount = {read=GetFragmentCount, nodefault};
	__property int InsertedCount = {read=GetInsertedCount, nodefault};
	__property int LastInserted = {read=fLastInserted, nodefault};
	__property AnsiString Fragments[int Index] = {read=GetFragment};
	__property TSMSProtocolStatus Status = {read=fStatus, nodefault};
	__property System::TDateTime Stamp = {read=fStamp};
	virtual TSMSProtocolInsertStatus __fastcall InsertFragment(const AnsiString aFragment) = 0 ;
	
__published:
	__property AnsiString Data = {read=GetData, write=SetData};
	__property int Reference = {read=fReference, write=SetReference, nodefault};
};


class DELPHICLASS TSMSProtocol2;
class PASCALIMPLEMENTATION TSMSProtocol2 : public TSMSProtocol 
{
	typedef TSMSProtocol inherited;
	
private:
	Word fSourceAddress;
	Word fDestinationAddress;
	TSMSProtocolOptionsSet fOptions;
	void __fastcall SetDestinationAddress(const Word Value);
	void __fastcall SetSourceAddress(const Word Value);
	void __fastcall SetOptions(const TSMSProtocolOptionsSet Value);
	
__published:
	__property Word SourceAddress = {read=fSourceAddress, write=SetSourceAddress, nodefault};
	__property Word DestinationAddress = {read=fDestinationAddress, write=SetDestinationAddress, nodefault};
	__property TSMSProtocolOptionsSet Options = {read=fOptions, write=SetOptions, nodefault};
public:
	#pragma option push -w-inl
	/* TSMSProtocol.Create */ inline __fastcall virtual TSMSProtocol2(void) : TSMSProtocol() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSMSProtocol.Destroy */ inline __fastcall virtual ~TSMSProtocol2(void) { }
	#pragma option pop
	
};


class DELPHICLASS TNBS;
class PASCALIMPLEMENTATION TNBS : public TSMSProtocol2 
{
	typedef TSMSProtocol2 inherited;
	
private:
	bool fBinary;
	AnsiString fOtherHeader;
	void __fastcall SetBinary(const bool Value);
	void __fastcall SetOtherHeader(const AnsiString Value);
	
protected:
	virtual void __fastcall EncodeFragments(void);
	
public:
	virtual TSMSProtocolInsertStatus __fastcall InsertFragment(const AnsiString aFragment);
	
__published:
	__property AnsiString OtherHeader = {read=fOtherHeader, write=SetOtherHeader};
	__property bool Binary = {read=fBinary, write=SetBinary, nodefault};
public:
	#pragma option push -w-inl
	/* TSMSProtocol.Create */ inline __fastcall virtual TNBS(void) : TSMSProtocol2() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSMSProtocol.Destroy */ inline __fastcall virtual ~TNBS(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIE;
class PASCALIMPLEMENTATION TIE : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Byte fIEI;
	AnsiString fIED;
	void __fastcall SetIED(const AnsiString Value);
	void __fastcall SetIEI(const Byte Value);
	
public:
	__property Byte IEI = {read=fIEI, write=SetIEI, nodefault};
	__property AnsiString IED = {read=fIED, write=SetIED};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TIE(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TIE(void) { }
	#pragma option pop
	
};


class DELPHICLASS TUDHProtocol;
class PASCALIMPLEMENTATION TUDHProtocol : public TSMSProtocol2 
{
	typedef TSMSProtocol2 inherited;
	
private:
	Contnrs::TObjectList* fIES;
	int fIESCounter;
	Byte fEncodeFlag;
	AnsiString __fastcall EncodeIEs();
	
protected:
	virtual void __fastcall EncodeFragments(void);
	virtual bool __fastcall GetNextIE(bool aReset, int aRemainingL, int aMaxL, TIE* &aIE);
	
public:
	__property Contnrs::TObjectList* IEs = {read=fIES};
	virtual TSMSProtocolInsertStatus __fastcall InsertFragment(const AnsiString aFragment);
	__fastcall virtual TUDHProtocol(void);
	__fastcall virtual ~TUDHProtocol(void);
	virtual void __fastcall Clear(void);
};


class DELPHICLASS TEMSUDHProtocol;
class PASCALIMPLEMENTATION TEMSUDHProtocol : public TUDHProtocol 
{
	typedef TUDHProtocol inherited;
	
private:
	Contnrs::TObjectList* fIEPending;
	int fIEPendingCounter;
	
protected:
	virtual bool __fastcall GetNextIE(bool aReset, int aRemainingL, int aMaxL, TIE* &aIE);
	
public:
	__fastcall virtual TEMSUDHProtocol(void);
	__fastcall virtual ~TEMSUDHProtocol(void);
};


class DELPHICLASS TSiemensOTA;
class PASCALIMPLEMENTATION TSiemensOTA : public TSMSProtocol 
{
	typedef TSMSProtocol inherited;
	
private:
	AnsiString fObjectType;
	AnsiString fObjectName;
	int fObjectSize;
	void __fastcall SetObjectName(const AnsiString Value);
	void __fastcall SetObjectType(const AnsiString Value);
	
protected:
	virtual void __fastcall EncodeFragments(void);
	
public:
	virtual TSMSProtocolInsertStatus __fastcall InsertFragment(const AnsiString aFragment);
	
__published:
	__property AnsiString ObjectName = {read=fObjectName, write=SetObjectName};
	__property AnsiString ObjectType = {read=fObjectType, write=SetObjectType};
public:
	#pragma option push -w-inl
	/* TSMSProtocol.Create */ inline __fastcall virtual TSiemensOTA(void) : TSMSProtocol() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSMSProtocol.Destroy */ inline __fastcall virtual ~TSiemensOTA(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSMSProtocolStack;
class PASCALIMPLEMENTATION TSMSProtocolStack : public Classes::TStringList 
{
	typedef Classes::TStringList inherited;
	
public:
	bool __fastcall ProcessSMS(Gsm::TSMS* aSMS, TSMSProtocol* &aId);
	void __fastcall RemoveSMSProtocol(TSMSProtocol* aId);
	void __fastcall CleanSMSProtocols(System::TDateTime aRelativeDT, bool aOnlyNotComplete);
public:
	#pragma option push -w-inl
	/* TStringList.Destroy */ inline __fastcall virtual ~TSMSProtocolStack(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TSMSProtocolStack(void) : Classes::TStringList() { }
	#pragma option pop
	
};


#pragma option push -b-
enum TDirectoryRecordHeader { drhFull, drhPartial, drhNone };
#pragma option pop

class DELPHICLASS TDirectoryRecords;
class PASCALIMPLEMENTATION TDirectoryRecords : public Classes::TStringList 
{
	typedef Classes::TStringList inherited;
	
private:
	int fFoldingLength;
	AnsiString fKind;
	TDirectoryRecordHeader fHeader;
	Classes::TStrings* __fastcall GetParams(int Index);
	Classes::TStrings* __fastcall GetParamsOf(AnsiString aName);
	AnsiString __fastcall GetData();
	void __fastcall SetData(const AnsiString Value);
	
protected:
	virtual System::TObject* __fastcall GetObject(int Index);
	
__published:
	__property int FoldingLength = {read=fFoldingLength, write=fFoldingLength, nodefault};
	__property AnsiString Data = {read=GetData, write=SetData};
	__property AnsiString Kind = {read=fKind, write=fKind};
	__property TDirectoryRecordHeader Header = {read=fHeader, write=fHeader, nodefault};
	
public:
	__fastcall virtual ~TDirectoryRecords(void);
	__property Classes::TStrings* Params[int Index] = {read=GetParams};
	__property Classes::TStrings* ParamsOf[AnsiString aName] = {read=GetParamsOf};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TDirectoryRecords(void) : Classes::TStringList() { }
	#pragma option pop
	
};


#pragma option push -b-
enum TSoundMelodyPatternScale { smps55Hz, smps110Hz, smps220Hz, smps440Hz, smps880Hz, smps1760Hz, smps3520Hz, smps7040Hz, smps14080Hz };
#pragma option pop

#pragma option push -b-
enum TSoundMelodyPatternNote { smgpnPause, smgpnC, smgpnCis, smgpnDes, smgpnD, smgpnDis, ssmgpnEs, mginE, smgpnEis, smgpnF, smgpnFis, smgpnGes, smgpnG, smgpnGis, smgpnAs, smgpnA, smgpnAis, smgpnB, smgpnH, smgpnHis };
#pragma option pop

#pragma option push -b-
enum TSoundMelodyPatternDuration { smgpdFull, smgpd2, smgpd4, smgpd8, smgpd16, smgpd32 };
#pragma option pop

#pragma option push -b-
enum TSoundMelodyPatternDurationSpecifier { smgpdsNoSpecial, smgpdsDotted, smgpdsDoubleDotted, smgpdsLength2_3 };
#pragma option pop

#pragma option push -b-
enum TSoundMelodyPatternStyle { smpsNatural, smpsContinuous, smpsStaccato };
#pragma option pop

struct TSoundMelodyPatternItem
{
	
public:
	TSoundMelodyPatternScale Scale;
	TSoundMelodyPatternNote Note;
	TSoundMelodyPatternDuration Duration;
	TSoundMelodyPatternDurationSpecifier DurationSpecifier;
	Byte Tempo;
	TSoundMelodyPatternStyle Style;
	Byte Volume;
	int Special;
} ;

typedef DynamicArray<TSoundMelodyPatternItem >  XSMS__11;

class DELPHICLASS TSoundMelody;
class PASCALIMPLEMENTATION TSoundMelody : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	void __fastcall AddLine(void);
	AnsiString __fastcall GetRTTTL();
	void __fastcall SetRTTTL(const AnsiString Value);
	
public:
	AnsiString Name;
	DynamicArray<TSoundMelodyPatternItem >  Pattern;
	__property AnsiString RTTTL = {read=GetRTTTL, write=SetRTTTL};
	__fastcall TSoundMelody(void);
	/*         class method */ static Word __fastcall DecodeBeatsPerMin(TMetaClass* vmt, Byte aBeats);
	/*         class method */ static Byte __fastcall EncodeBeatsPerMin(TMetaClass* vmt, Word aBeats);
	void __fastcall InitPattern(void);
	Classes::TStrings* __fastcall CreateStrings(void);
	void __fastcall AssignStrings(Classes::TStrings* Sg);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TSoundMelody(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSmartMessage;
class PASCALIMPLEMENTATION TSmartMessage : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	AnsiString __fastcall GetData();
	void __fastcall SetData(const AnsiString Value);
	
protected:
	virtual AnsiString __fastcall Encode(void) = 0 ;
	virtual void __fastcall Decode(const AnsiString Value) = 0 ;
	
public:
	/*         class method */ static TSmartMessage* __fastcall CreateSM(TMetaClass* vmt, const AnsiString aData, Word aPort);
	__fastcall virtual TSmartMessage(void);
	__property AnsiString Data = {read=GetData, write=SetData};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TSmartMessage(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TSmartMessageClass;

class DELPHICLASS TSMMIMEDirectory;
class PASCALIMPLEMENTATION TSMMIMEDirectory : public TSmartMessage 
{
	typedef TSmartMessage inherited;
	
private:
	TDirectoryRecords* fRecords;
	
protected:
	virtual AnsiString __fastcall Encode();
	virtual void __fastcall Decode(const AnsiString Value);
	
public:
	__fastcall virtual TSMMIMEDirectory(void);
	__fastcall virtual ~TSMMIMEDirectory(void);
	__property TDirectoryRecords* Records = {read=fRecords};
};


class DELPHICLASS TSMvCard;
class PASCALIMPLEMENTATION TSMvCard : public TSMMIMEDirectory 
{
	typedef TSMMIMEDirectory inherited;
	
public:
	__fastcall virtual TSMvCard(void);
public:
	#pragma option push -w-inl
	/* TSMMIMEDirectory.Destroy */ inline __fastcall virtual ~TSMvCard(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSMvCalendar;
class PASCALIMPLEMENTATION TSMvCalendar : public TSMMIMEDirectory 
{
	typedef TSMMIMEDirectory inherited;
	
public:
	__fastcall virtual TSMvCalendar(void);
public:
	#pragma option push -w-inl
	/* TSMMIMEDirectory.Destroy */ inline __fastcall virtual ~TSMvCalendar(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSMOTABitmap;
class PASCALIMPLEMENTATION TSMOTABitmap : public TSmartMessage 
{
	typedef TSmartMessage inherited;
	
private:
	AnsiString fInfoFields;
	int fWidth;
	int fHeight;
	Byte fDepth;
	AnsiString fPalette;
	Classes::TList* fImages;
	int __fastcall GetAnimatedImageCount(void);
	Byte __fastcall GetInfoFieldCount(void);
	Byte __fastcall GetInfoFields(int Index);
	Types::TPoint __fastcall GetSize();
	void __fastcall SetAnimatedImageCount(const int Value);
	void __fastcall SetHeight(const int Value);
	void __fastcall SetInfoFieldCount(const Byte Value);
	void __fastcall SetInfoFields(int Index, const Byte Value);
	void __fastcall SetSize(const Types::TPoint &Value);
	void __fastcall SetWidth(const int Value);
	void __fastcall SetImage(int Index, Graphics::TBitmap* aBitmap);
	Graphics::TBitmap* __fastcall GetImage(int Index);
	void __fastcall AdjustInfoFields(void);
	void __fastcall AdjustSize(void);
	void __fastcall AdjustImages(int I);
	void __fastcall CheckSupport(void);
	
protected:
	virtual AnsiString __fastcall Encode();
	virtual void __fastcall Decode(const AnsiString Value);
	
public:
	__property Byte InfoFieldCount = {read=GetInfoFieldCount, write=SetInfoFieldCount, nodefault};
	__property Byte InfoFields[int Index] = {read=GetInfoFields, write=SetInfoFields};
	__property int AnimatedImageCount = {read=GetAnimatedImageCount, write=SetAnimatedImageCount, nodefault};
	__property int Width = {read=fWidth, write=SetWidth, nodefault};