advobj.hpp

TMS component pack v4.2 for delphi

// CodeGear C++ Builder
// Copyright (c) 1995, 2007 by CodeGear
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Advobj.pas' rev: 11.00

#ifndef AdvobjHPP
#define AdvobjHPP

#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 <Windows.hpp>	// Pascal unit
#include <Stdctrls.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Extctrls.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Advutil.hpp>	// Pascal unit
#include <Asghtmle.hpp>	// Pascal unit
#include <Buttons.hpp>	// Pascal unit
#include <Menus.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Advxpvs.hpp>	// Pascal unit
#include <Actnlist.hpp>	// Pascal unit

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

namespace Advobj
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TArrowDirection { arrUp, arrDown, arrLeft, arrRight };
#pragma option pop

#pragma option push -b-
enum TAdvGridButtonStyle { tasButton, tasCheck };
#pragma option pop

typedef void __fastcall (__closure *TImageChangeEvent)(System::TObject* Sender, int Acol, int Arow);

class DELPHICLASS TArrowWindow;
class PASCALIMPLEMENTATION TArrowWindow : public Extctrls::TPanel 
{
	typedef Extctrls::TPanel inherited;
	
private:
	TArrowDirection Dir;
	Types::TPoint Arrow[9];
	
public:
	__fastcall TArrowWindow(Classes::TComponent* AOwner, TArrowDirection direction);
	virtual void __fastcall Loaded(void);
	
protected:
	virtual void __fastcall CreateWnd(void);
	virtual void __fastcall Paint(void);
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
public:
	#pragma option push -w-inl
	/* TCustomPanel.Create */ inline __fastcall virtual TArrowWindow(Classes::TComponent* AOwner) : Extctrls::TPanel(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TCustomControl.Destroy */ inline __fastcall virtual ~TArrowWindow(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TArrowWindow(HWND ParentWindow) : Extctrls::TPanel(ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TPopupButton;
class PASCALIMPLEMENTATION TPopupButton : public Controls::TCustomControl 
{
	typedef Controls::TCustomControl inherited;
	
private:
	AnsiString FCaption;
	Controls::TImageList* FImages;
	bool FFlat;
	Graphics::TColor FGradTo;
	Graphics::TColor FGradFrom;
	
protected:
	virtual void __fastcall CreateParams(Controls::TCreateParams &Params);
	
public:
	__fastcall virtual TPopupButton(Classes::TComponent* AOwner);
	virtual void __fastcall Paint(void);
	virtual void __fastcall CreateWnd(void);
	__property Controls::TImageList* Images = {read=FImages, write=FImages};
	
__published:
	__property AnsiString Caption = {read=FCaption, write=FCaption};
	__property bool Flat = {read=FFlat, write=FFlat, nodefault};
	__property Graphics::TColor GradFrom = {read=FGradFrom, write=FGradFrom, nodefault};
	__property Graphics::TColor GradTo = {read=FGradTo, write=FGradTo, nodefault};
public:
	#pragma option push -w-inl
	/* TCustomControl.Destroy */ inline __fastcall virtual ~TPopupButton(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TPopupButton(HWND ParentWindow) : Controls::TCustomControl(ParentWindow) { }
	#pragma option pop
	
};


class DELPHICLASS TIntList;
class PASCALIMPLEMENTATION TIntList : public Classes::TList 
{
	typedef Classes::TList inherited;
	
public:
	int operator[](int index) { return Items[index]; }
	
private:
	TImageChangeEvent FOnChange;
	int FCol;
	int FRow;
	void __fastcall SetInteger(int Index, int Value);
	int __fastcall GetInteger(int Index);
	AnsiString __fastcall GetStrValue();
	void __fastcall SetStrValue(const AnsiString Value);
	
public:
	__fastcall TIntList(int Col, int Row);
	void __fastcall DeleteValue(int Value);
	bool __fastcall HasValue(int Value);
	__property int Items[int index] = {read=GetInteger, write=SetInteger/*, default*/};
	HIDESBASE void __fastcall Add(int Value);
	HIDESBASE void __fastcall Insert(int Index, int Value);
	HIDESBASE void __fastcall Delete(int Index);
	__property AnsiString StrValue = {read=GetStrValue, write=SetStrValue};
	
__published:
	__property TImageChangeEvent OnChange = {read=FOnChange, write=FOnChange};
public:
	#pragma option push -w-inl
	/* TList.Destroy */ inline __fastcall virtual ~TIntList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSortIndexList;
class PASCALIMPLEMENTATION TSortIndexList : public TIntList 
{
	typedef TIntList inherited;
	
private:
	int __fastcall GetSortColumns(int i);
	bool __fastcall GetSortDirections(int i);
	void __fastcall SetSortColumns(int i, const int Value);
	void __fastcall SetSortDirections(int i, const bool Value);
	
public:
	void __fastcall AddIndex(int ColumnIndex, bool Ascending);
	int __fastcall FindIndex(int ColumnIndex);
	void __fastcall ToggleIndex(int ColumnIndex);
	__property int SortColumns[int i] = {read=GetSortColumns, write=SetSortColumns};
	__property bool SortDirections[int i] = {read=GetSortDirections, write=SetSortDirections};
public:
	#pragma option push -w-inl
	/* TIntList.Create */ inline __fastcall TSortIndexList(int Col, int Row) : TIntList(Col, Row) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TList.Destroy */ inline __fastcall virtual ~TSortIndexList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TControlItem;
class PASCALIMPLEMENTATION TControlItem : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	int FX;
	int FY;
	Controls::TControl* FObject;
	
public:
	__fastcall TControlItem(int AX, int AY, Controls::TControl* AObject);
	
__published:
	__property int X = {read=FX, write=FY, nodefault};
	__property int Y = {read=FY, write=FY, nodefault};
	__property Controls::TControl* Control = {read=FObject, write=FObject};
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TControlItem(void) { }
	#pragma option pop
	
};


class DELPHICLASS TControlList;
class PASCALIMPLEMENTATION TControlList : public Classes::TList 
{
	typedef Classes::TList inherited;
	
private:
	TControlItem* __fastcall GetControl(int i);
	
public:
	void __fastcall AddControl(int X, int Y, Controls::TControl* AObject);
	void __fastcall RemoveControl(int i);
	int __fastcall ControlIndex(int X, int Y);
	__property TControlItem* Control[int i] = {read=GetControl};
	__fastcall virtual ~TControlList(void);
	bool __fastcall HasHandle(unsigned Handle);
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TControlList(void) : Classes::TList() { }
	#pragma option pop