aqdockingutils.hpp

AutomatedDocking Library 控件源代码修改 适合Delphi 2009 和C++ Builder 20009 使用。 修正汉字不能正确显示问题

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

// (DO NOT EDIT: machine generated header) 'Aqdockingutils.pas' rev: 20.00

#ifndef AqdockingutilsHPP
#define AqdockingutilsHPP

#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 <Types.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Commctrl.hpp>	// Pascal unit
#include <Imglist.hpp>	// Pascal unit
#include <Activex.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Extctrls.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Menus.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Comctrls.hpp>	// Pascal unit
#include <Appevnts.hpp>	// Pascal unit
#include <Contnrs.hpp>	// Pascal unit

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

namespace Aqdockingutils
{
//-- type declarations -------------------------------------------------------
typedef Controls::TWinControl* TaqControl;

typedef unsigned TaqHandle;

typedef unsigned *PaqHandle;

typedef unsigned *PHandle;

typedef int TaqRegionComplexity;

struct TaqBucketListItem
{
	
public:
	void *Key;
	void *Data;
};


class DELPHICLASS TaqCustomBucketListIterator;
class PASCALIMPLEMENTATION TaqCustomBucketListIterator : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	virtual void __fastcall Reset(void) = 0 ;
	virtual bool __fastcall HasNext(void) = 0 ;
	virtual TaqBucketListItem __fastcall Next(void) = 0 ;
public:
	/* TObject.Create */ inline __fastcall TaqCustomBucketListIterator(void) : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TaqCustomBucketListIterator(void) { }
	
};


class DELPHICLASS TaqBucketList;
class PASCALIMPLEMENTATION TaqBucketList : public Contnrs::TBucketList
{
	typedef Contnrs::TBucketList inherited;
	
private:
	int FCount;
	
protected:
	virtual void * __fastcall AddItem(int ABucket, void * AItem, void * AData);
	virtual void * __fastcall DeleteItem(int ABucket, int AIndex);
	
public:
	TaqCustomBucketListIterator* __fastcall Iterator(void);
	__property int Count = {read=FCount, nodefault};
public:
	/* TBucketList.Create */ inline __fastcall TaqBucketList(Contnrs::TBucketListSizes ABuckets) : Contnrs::TBucketList(ABuckets) { }
	
public:
	/* TCustomBucketList.Destroy */ inline __fastcall virtual ~TaqBucketList(void) { }
	
};


class DELPHICLASS TaqIntegerList;
class PASCALIMPLEMENTATION TaqIntegerList : public TaqBucketList
{
	typedef TaqBucketList inherited;
	
public:
	System::TObject* operator[](int AIndex) { return Data[AIndex]; }
	
private:
	HIDESBASE System::TObject* __fastcall GetData(int AIndex);
	HIDESBASE void __fastcall SetData(int AIndex, const System::TObject* Value);
	
public:
	__fastcall TaqIntegerList(void);
	HIDESBASE System::TObject* __fastcall Add(int AIndex, System::TObject* AData);
	__property System::TObject* Data[int AIndex] = {read=GetData, write=SetData/*, default*/};
public:
	/* TCustomBucketList.Destroy */ inline __fastcall virtual ~TaqIntegerList(void) { }
	
};


class DELPHICLASS TaqClassObjectList;
class PASCALIMPLEMENTATION TaqClassObjectList : public TaqBucketList
{
	typedef TaqBucketList inherited;
	
public:
	System::TObject* operator[](System::TClass AItem) { return Data[AItem]; }
	
private:
	bool FOwnItems;
	
protected:
	HIDESBASE System::TObject* __fastcall GetData(System::TClass AItem);
	HIDESBASE void __fastcall SetData(System::TClass AItem, const System::TObject* AData);
	virtual void * __fastcall DeleteItem(int ABucket, int AIndex);
	
public:
	__fastcall TaqClassObjectList(bool AOwnItems);
	HIDESBASE System::TObject* __fastcall Add(System::TClass AItem, System::TObject* AData);
	HIDESBASE System::TObject* __fastcall Remove(System::TClass AItem);
	System::TObject* __fastcall FindParented(System::TClass AItem);
	__property System::TObject* Data[System::TClass AItem] = {read=GetData, write=SetData/*, default*/};
public:
	/* TCustomBucketList.Destroy */ inline __fastcall virtual ~TaqClassObjectList(void) { }
	
};


class DELPHICLASS TaqClassList;
typedef void __fastcall (__closure *TaqClassListEvent)(TaqClassList* Sender, const System::UnicodeString ClassName, Classes::TPersistentClass Item);

class PASCALIMPLEMENTATION TaqClassList : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	Classes::TPersistentClass operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TStrings* FItems;
	TaqClassListEvent FOnUnregister;
	TaqClassListEvent FOnRegister;
	int __fastcall GetCount(void);
	Classes::TPersistentClass __fastcall GetItem(int Index);
	System::UnicodeString __fastcall GetName(Classes::TPersistentClass Item);
	
protected:
	virtual void __fastcall DoRegister(const System::UnicodeString ClassName, Classes::TPersistentClass Item);
	virtual void __fastcall DoUnregister(const System::UnicodeString ClassName, Classes::TPersistentClass Item);
	
public:
	__fastcall TaqClassList(void);
	__fastcall virtual ~TaqClassList(void);
	System::UnicodeString __fastcall GetClassName(int Index);
	Classes::TPersistentClass __fastcall FindClass(const System::UnicodeString Name);
	void __fastcall RegisterClass(const System::UnicodeString Name, Classes::TPersistentClass Item);
	Classes::TPersistentClass __fastcall UnregisterClass(const System::UnicodeString Name);
	__property int Count = {read=GetCount, nodefault};
	__property Classes::TPersistentClass Items[int Index] = {read=GetItem/*, default*/};
	__property System::UnicodeString Names[Classes::TPersistentClass Item] = {read=GetName};
	__property TaqClassListEvent OnRegister = {read=FOnRegister, write=FOnRegister};
	__property TaqClassListEvent OnUnregister = {read=FOnUnregister, write=FOnUnregister};
};


struct TaqStringEntry;
typedef TaqStringEntry *PaqStringEntry;

#pragma pack(push,1)
struct TaqStringEntry
{
	
public:
	System::UnicodeString Key;
	void *Value;
	TaqStringEntry *Next;
};
#pragma pack(pop)


typedef DynamicArray<PaqStringEntry> TaqStringArray;

class DELPHICLASS TaqStringList;
class PASCALIMPLEMENTATION TaqStringList : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	void * operator[](const System::UnicodeString Key) { return Items[Key]; }
	
private:
	TaqStringArray FItems;
	int FCount;
	int FCapacity;
	int FThreshold;
	float FLoadFactor;
	int __fastcall CalculateHash(const System::UnicodeString Value);
	void __fastcall Rehash(void);
	void * __fastcall Get(const System::UnicodeString Key);
	void __fastcall Put(const System::UnicodeString Key, void * Value);
	PaqStringEntry __fastcall FindItem(const System::UnicodeString Key);
	
public:
	__fastcall TaqStringList(int Capacity);
	__fastcall virtual ~TaqStringList(void);
	void * __fastcall Add(const System::UnicodeString Key, void * Data);
	void * __fastcall Remove(const System::UnicodeString Key);
	bool __fastcall Find(const System::UnicodeString Key, /* out */ void * &Value);
	void __fastcall Clear(void);
	TaqCustomBucketListIterator* __fastcall Iterator(void);
	__property void * Items[const System::UnicodeString Key] = {read=Get, write=Put/*, default*/};
	__property int Count = {read=FCount, nodefault};
};


typedef void __fastcall (__closure *TaqWindowNotifyEvent)(Controls::TControl* Sender);

class DELPHICLASS TaqWindowEventFilter;
class PASCALIMPLEMENTATION TaqWindowEventFilter : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	unsigned FControlHandle;