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

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

#ifndef AdvsmoothlistboxHPP
#define AdvsmoothlistboxHPP

#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 <Forms.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Stdctrls.hpp>	// Pascal unit
#include <Comobj.hpp>	// Pascal unit
#include <Activex.hpp>	// Pascal unit
#include <Advsmoothgdip.hpp>	// Pascal unit
#include <Advstyleif.hpp>	// Pascal unit
#include <Imglist.hpp>	// Pascal unit
#include <Advsmooththeme.hpp>	// Pascal unit
#include <Gdippicturecontainer.hpp>	// Pascal unit
#include <Extctrls.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Gdipfill.hpp>	// Pascal unit
#include <Menus.hpp>	// Pascal unit

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

namespace Advsmoothlistbox
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TAdvSmoothListBoxLocation { plTopLeft, plTopCenter, plTopRight, plCenterLeft, plCenterCenter, plCenterRight, plBottomLeft, plBottomCenter, plBottomRight, plCustom };
#pragma option pop

#pragma option push -b-
enum TAdvSmoothListBoxShowDetailClick { sdOnClick, sdOnDetailImageClick, sdOnDblClick, sdOnDetailImageDblClick };
#pragma option pop

#pragma option push -b-
enum TAdvSmoothListBoxShowDetailKey { dkSpace, dkNone, dkF2, dkReturn };
#pragma option pop

class DELPHICLASS TAdvSmoothListBoxItemAppearance;
class DELPHICLASS TAdvSmoothListBox;
class DELPHICLASS TAdvSmoothListBoxItem;
#pragma option push -b-
enum TAdvSmoothListBoxGraphicType { gtCheckBox, gtRadio, gtButton, gtImage, gtDetailImage, gtCommonImage, gtCommonDetailImage };
#pragma option pop

#pragma option push -b-
enum TAdvSmoothListBoxGraphicShow { gsAlways, gsSelected, gsEnabled, gsNever };
#pragma option pop

class PASCALIMPLEMENTATION TAdvSmoothListBoxItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	bool FMouseEntered;
	bool FMouseLeft;
	#pragma pack(push,1)
	Types::TRect fgrRight;
	#pragma pack(pop)
	#pragma pack(push,1)
	Types::TRect fgrLeft;
	#pragma pack(pop)
	#pragma pack(push,1)
	Types::TRect fcaptionr;
	#pragma pack(pop)
	#pragma pack(push,1)
	Types::TRect finfor;
	#pragma pack(pop)
	AnsiString fn;
	#pragma pack(push,1)
	Types::TRect Fhtmlr;
	#pragma pack(pop)
	AnsiString FCaption;
	bool FEnabled;
	TAdvSmoothListBoxGraphicType FGraphicLeftType;
	TAdvSmoothListBoxGraphicShow FGraphicLeftShow;
	Classes::TAlignment FCaptionAlignment;
	TAdvSmoothListBoxGraphicType FGraphicRightType;
	AnsiString FNotes;
	Advsmoothgdip::TAdvGDIPPicture* FGraphicLeft;
	TAdvSmoothListBoxGraphicShow FGraphicRightShow;
	Advsmoothgdip::TAdvGDIPPicture* FGraphicRight;
	AnsiString FInfo;
	Graphics::TFont* FCaptionFont;
	Graphics::TFont* FInfoFont;
	Controls::TControl* FControl;
	bool FSplitter;
	int FNotesTop;
	int FNotesLeft;
	Graphics::TColor FNoteshadowColor;
	TAdvSmoothListBoxLocation FNotesLocation;
	Graphics::TColor FNotesURLColor;
	int FNotesShadowOffset;
	System::TObject* FObject;
	int FTag;
	bool FChecked;
	int FMargin;
	int FGraphicLeftMargin;
	int FGraphicRightMargin;
	Graphics::TFont* FNotesFont;
	AnsiString FHint;
	bool FSelected;
	int FCategoryID;
	void __fastcall SetCaption(const AnsiString Value);
	void __fastcall SetEnabled(const bool Value);
	void __fastcall SetCaptionAlignment(const Classes::TAlignment Value);
	void __fastcall SetGraphicLeft(const Advsmoothgdip::TAdvGDIPPicture* Value);
	void __fastcall SetGraphicLeftShow(const TAdvSmoothListBoxGraphicShow Value);
	void __fastcall SetGraphicLeftType(const TAdvSmoothListBoxGraphicType Value);
	void __fastcall SetGraphicRight(const Advsmoothgdip::TAdvGDIPPicture* Value);
	void __fastcall SetGraphicRightShow(const TAdvSmoothListBoxGraphicShow Value);
	void __fastcall SetGraphicRightType(const TAdvSmoothListBoxGraphicType Value);
	void __fastcall SetInfo(const AnsiString Value);
	void __fastcall SetNotes(const AnsiString Value);
	void __fastcall SetCaptionFont(const Graphics::TFont* Value);
	void __fastcall SetInfoFont(const Graphics::TFont* Value);
	void __fastcall SetControl(const Controls::TControl* Value);
	void __fastcall SetSplitter(const bool Value);
	void __fastcall SetNotesLeft(const int Value);
	void __fastcall SetNotesLocation(const TAdvSmoothListBoxLocation Value);
	void __fastcall SetNotesShadowColor(const Graphics::TColor Value);
	void __fastcall SetNotesShadowOffset(const int Value);
	void __fastcall SetNotesTop(const int Value);
	void __fastcall SetNotesURLColor(const Graphics::TColor Value);
	void __fastcall SetChecked(const bool Value);
	void __fastcall SetMargin(const int Value);
	void __fastcall SetGraphicLeftMargin(const int Value);
	void __fastcall SetGraphicRightMargin(const int Value);
	void __fastcall SetNotesFont(const Graphics::TFont* Value);
	void __fastcall SetHint(const AnsiString Value);
	void __fastcall SetSelected(const bool Value);
	void __fastcall SetCategoryID(const int Value);
	
protected:
	HIDESBASE void __fastcall Changed(void);
	void __fastcall PictureChanged(System::TObject* Sender);
	void __fastcall FontChanged(System::TObject* Sender);
	void __fastcall Draw(Graphics::TCanvas* ACanvas, const Types::TRect &R, int DisplayIndex);
	virtual AnsiString __fastcall GetDisplayName();
	
public:
	__fastcall virtual TAdvSmoothListBoxItem(Classes::TCollection* Collection);
	__fastcall virtual ~TAdvSmoothListBoxItem(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall AssignVisuals(Classes::TPersistent* Source);
	void __fastcall SaveItemValues(AnsiString Caption, AnsiString Info, AnsiString Notes);
	AnsiString __fastcall GetAnchorAt(int X, int Y);
	__property System::TObject* ItemObject = {read=FObject, write=FObject};
	
__published:
	__property AnsiString Caption = {read=FCaption, write=SetCaption};
	__property bool Checked = {read=FChecked, write=SetChecked, default=0};
	__property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
	__property Classes::TAlignment CaptionAlignment = {read=FCaptionAlignment, write=SetCaptionAlignment, default=0};
	__property AnsiString Notes = {read=FNotes, write=SetNotes};
	__property Graphics::TColor NotesURLColor = {read=FNotesURLColor, write=SetNotesURLColor, default=16711680};
	__property Graphics::TColor NotesShadowColor = {read=FNoteshadowColor, write=SetNotesShadowColor, default=8421504};
	__property int NotesShadowOffset = {read=FNotesShadowOffset, write=SetNotesShadowOffset, default=5};
	__property TAdvSmoothListBoxLocation NotesLocation = {read=FNotesLocation, write=SetNotesLocation, default=4};
	__property int NotesLeft = {read=FNotesLeft, write=SetNotesLeft, default=0};
	__property int NotesTop = {read=FNotesTop, write=SetNotesTop, default=0};
	__property AnsiString Info = {read=FInfo, write=SetInfo};
	__property AnsiString Hint = {read=FHint, write=SetHint};
	__property int GraphicLeftMargin = {read=FGraphicLeftMargin, write=SetGraphicLeftMargin, default=3};
	__property int GraphicRightMargin = {read=FGraphicRightMargin, write=SetGraphicRightMargin, default=3};
	__property TAdvSmoothListBoxGraphicType GraphicLeftType = {read=FGraphicLeftType, write=SetGraphicLeftType, default=3};
	__property TAdvSmoothListBoxGraphicType GraphicRightType = {read=FGraphicRightType, write=SetGraphicRightType, default=3};
	__property Advsmoothgdip::TAdvGDIPPicture* GraphicLeft = {read=FGraphicLeft, write=SetGraphicLeft};
	__property Advsmoothgdip::TAdvGDIPPicture* GraphicRight = {read=FGraphicRight, write=SetGraphicRight};
	__property TAdvSmoothListBoxGraphicShow GraphicLeftShow = {read=FGraphicLeftShow, write=SetGraphicLeftShow, default=0};
	__property TAdvSmoothListBoxGraphicShow GraphicRightShow = {read=FGraphicRightShow, write=SetGraphicRightShow, default=0};
	__property Graphics::TFont* CaptionFont = {read=FCaptionFont, write=SetCaptionFont};
	__property Graphics::TFont* InfoFont = {read=FInfoFont, write=SetInfoFont};
	__property Graphics::TFont* NotesFont = {read=FNotesFont, write=SetNotesFont};
	__property Controls::TControl* DetailControl = {read=FControl, write=SetControl};
	__property int Tag = {read=FTag, write=FTag, nodefault};
	__property bool Splitter = {read=FSplitter, write=SetSplitter, nodefault};
	__property int CaptionMargin = {read=FMargin, write=SetMargin, default=3};
	__property bool Selected = {read=FSelected, write=SetSelected, default=0};
	__property int CategoryID = {read=FCategoryID, write=SetCategoryID, default=-1};
};


#pragma option push -b-
enum TDragMode { dmDrag, dmRelease };
#pragma option pop

class DELPHICLASS TAdvSmoothListBoxItems;
class PASCALIMPLEMENTATION TAdvSmoothListBoxItems : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TAdvSmoothListBoxItem* operator[](int Index) { return Items[Index]; }
	
private:
	int FUpdateCount;
	TAdvSmoothListBox* FOwner;
	Classes::TNotifyEvent FOnChange;
	TAdvSmoothListBoxItem* FSelectedItem;
	HIDESBASE TAdvSmoothListBoxItem* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TAdvSmoothListBoxItem* Value);
	void __fastcall SetSelectedItem(const TAdvSmoothListBoxItem* Value);
	
protected:
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	virtual int __fastcall Compare(TAdvSmoothListBoxItem* Item1, TAdvSmoothListBoxItem* Item2);
	void __fastcall QuickSort(int L, int R);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	virtual void __fastcall BeginUpdate(void);
	virtual void __fastcall EndUpdate(void);
	__fastcall TAdvSmoothListBoxItems(TAdvSmoothListBox* AOwner);
	__property TAdvSmoothListBoxItem* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	HIDESBASE TAdvSmoothListBoxItem* __fastcall Add(void);
	HIDESBASE TAdvSmoothListBoxItem* __fastcall Insert(int Index);
	HIDESBASE void __fastcall Delete(int Index);
	void __fastcall Sort(void);
	HIDESBASE void __fastcall Clear(void);
	__property TAdvSmoothListBoxItem* SelectedItem = {read=FSelectedItem, write=SetSelectedItem};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAdvSmoothListBoxItems(void) { }
	#pragma option pop
	
};


class DELPHICLASS TAdvSmoothListBoxDisplayList;
class DELPHICLASS TAdvSmoothListBoxDisplayListItem;
class PASCALIMPLEMENTATION TAdvSmoothListBoxDisplayList : public Classes::TList 
{
	typedef Classes::TList inherited;
	
public:
	virtual void __fastcall Clear(void);
	void __fastcall DeleteItem(int index);
	TAdvSmoothListBoxDisplayListItem* __fastcall AddItem(void);
	TAdvSmoothListBoxDisplayListItem* __fastcall GetItem(int index);
public:
	#pragma option push -w-inl
	/* TList.Destroy */ inline __fastcall virtual ~TAdvSmoothListBoxDisplayList(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TAdvSmoothListBoxDisplayList(void) : Classes::TList() { }
	#pragma option pop
	
};


class DELPHICLASS TAdvSmoothListBoxLookUpBar;
#pragma option push -b-
enum TAdvSmoothListBoxLookUpBarPosition { pLeft, pRight };
#pragma option pop

class PASCALIMPLEMENTATION TAdvSmoothListBoxLookUpBar : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FChar[36];
	DynamicArray<bool >  FCustomChar;
	TAdvSmoothListBox* Fowner;
	Graphics::TFont* FDisabledFont;
	Graphics::TColor FColor;
	Graphics::TColor FColorTo;
	Graphics::TFont* FFont;
	bool FVisible;
	bool FNumeric;
	Classes::TNotifyEvent FOnChange;
	TAdvSmoothListBoxLookUpBarPosition FPosition;
	Byte FOpacity;
	Byte FOpacityTo;
	Advsmoothgdip::TAdvGradientType FGradientType;
	Advsmoothgdip::HatchStyle FHatchStyle;
	bool FOnTop;
	bool FAutoSize;
	int FSpacing;
	bool FRotated;
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetDisabledFont(const Graphics::TFont* Value);
	void __fastcall SetFont(const Graphics::TFont* Value);
	void __fastcall SetNumeric(const bool Value);
	void __fastcall SetPosition(const TAdvSmoothListBoxLookUpBarPosition Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetOpacity(const Byte Value);
	void __fastcall SetOpacityTo(const Byte Value);
	void __fastcall SetGradientType(const Advsmoothgdip::TAdvGradientType Value);
	void __fastcall SetHatchStyle(const Advsmoothgdip::HatchStyle Value);
	void __fastcall SetOnTop(const bool Value);
	void __fastcall SetAutoSize(const bool Value);
	void __fastcall SetRotated(const bool Value);
	void __fastcall SetSpacing(const int Value);
	
protected:
	void __fastcall Changed(void);
	void __fastcall FontChanged(System::TObject* Sender);
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	void __fastcall InitLookupBar(void);
	
public:
	__fastcall TAdvSmoothListBoxLookUpBar(TAdvSmoothListBox* AOwner);
	__fastcall virtual ~TAdvSmoothListBoxLookUpBar(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	int __fastcall GetWidth(void);
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=16777215};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=16777215};
	__property Advsmoothgdip::TAdvGradientType GradientType = {read=FGradientType, write=SetGradientType, default=0};
	__property Advsmoothgdip::HatchStyle HatchStyle = {read=FHatchStyle, write=SetHatchStyle, default=0};
	__property Byte Opacity = {read=FOpacity, write=SetOpacity, default=100};
	__property Byte OpacityTo = {read=FOpacityTo, write=SetOpacityTo, default=100};
	__property bool Numeric = {read=FNumeric, write=SetNumeric, default=0};
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
	__property TAdvSmoothListBoxLookUpBarPosition Position = {read=FPosition, write=SetPosition, default=1};
	__property Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property bool OnTop = {read=FOnTop, write=SetOnTop, default=0};
	__property Graphics::TFont* DisabledFont = {read=FDisabledFont, write=SetDisabledFont};
	__property int Spacing = {read=FSpacing, write=SetSpacing, default=3};
	__property bool AutoSize = {read=FAutoSize, write=SetAutoSize, default=1};
	__property bool Rotated = {read=FRotated, write=SetRotated, default=0};
};


class DELPHICLASS TAdvSmoothListBoxSections;
#pragma option push -b-
enum TAdvSmoothListBoxCategoryType { alphanumeric, custom };
#pragma option pop

class DELPHICLASS TAdvSmoothListBoxCategoryItems;
class DELPHICLASS TAdvSmoothListBoxCategoryItem;
class PASCALIMPLEMENTATION TAdvSmoothListBoxCategoryItems : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TAdvSmoothListBoxCategoryItem* operator[](int Index) { return Items[Index]; }
	
private:
	TAdvSmoothListBox* FOwner;
	Classes::TNotifyEvent FOnChange;
	HIDESBASE TAdvSmoothListBoxCategoryItem* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TAdvSmoothListBoxCategoryItem* Value);
	
protected:
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual int __fastcall Compare(TAdvSmoothListBoxCategoryItem* Item1, TAdvSmoothListBoxCategoryItem* Item2);
	void __fastcall QuickSort(int L, int R);
	
public:
	__fastcall TAdvSmoothListBoxCategoryItems(TAdvSmoothListBox* AOwner);
	__property TAdvSmoothListBoxCategoryItem* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	TAdvSmoothListBoxCategoryItem* __fastcall ItemById(int id);
	int __fastcall ItemIndexById(int id);
	HIDESBASE TAdvSmoothListBoxCategoryItem* __fastcall Add(void);
	HIDESBASE TAdvSmoothListBoxCategoryItem* __fastcall Insert(int Index);
	HIDESBASE void __fastcall Delete(int Index);
	void __fastcall Sort(void);
	HIDESBASE void __fastcall Clear(void);
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TAdvSmoothListBoxCategoryItems(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TAdvSmoothListBoxSections : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	Byte FOpacity;
	Graphics::TColor FBorderColor;
	Advsmoothgdip::TAdvGradientType FGradientType;
	Byte FOpacityTo;
	Advsmoothgdip::HatchStyle FHatchStyle;
	Graphics::TColor FColor;
	Graphics::TColor FColorTo;
	Graphics::TFont* FFont;
	bool FVisible;
	Classes::TNotifyEvent FOnChange;
	TAdvSmoothListBoxCategoryType FCategoryType;
	int FBorderWidth;
	TAdvSmoothListBoxCategoryItems* FCategories;
	void __fastcall SetBorderColor(const Graphics::TColor Value);
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetFont(const Graphics::TFont* Value);
	void __fastcall SetGradientType(const Advsmoothgdip::TAdvGradientType Value);
	void __fastcall SetHatchStyle(const Advsmoothgdip::HatchStyle Value);
	void __fastcall SetOpacity(const Byte Value);
	void __fastcall SetOpacityTo(const Byte Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetBorderWidth(const int Value);
	
public:
	void __fastcall Changed(void);
	void __fastcall FontChanged(System::TObject* Sender);
	void __fastcall CategoriesChanged(System::TObject* Sender);
	__fastcall TAdvSmoothListBoxSections(TAdvSmoothListBox* AOwner);
	__fastcall virtual ~TAdvSmoothListBoxSections(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property bool Visible = {read=FVisible, write=SetVisible, default=0};
	__property Advsmoothgdip::TAdvGradientType GradientType = {read=FGradientType, write=SetGradientType, default=0};
	__property Advsmoothgdip::HatchStyle HatchStyle = {read=FHatchStyle, write=SetHatchStyle, default=0};
	__property Graphics::TColor BorderColor = {read=FBorderColor, write=SetBorderColor, default=12632256};
	__property int BorderWidth = {read=FBorderWidth, write=SetBorderWidth, default=1};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=16777215};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=12632256};
	__property Byte Opacity = {read=FOpacity, write=SetOpacity, default=180};
	__property Byte OpacityTo = {read=FOpacityTo, write=SetOpacityTo, default=180};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


class DELPHICLASS TAdvSmoothListBoxHeaderFooter;
#pragma option push -b-
enum TAdvSmoothListBoxCaptionLocation { cpTopLeft, cpTopCenter, cpTopRight, cpCenterLeft, cpCenterCenter, cpCenterRight, cpBottomLeft, cpBottomCenter, cpBottomRight, cpCustom };
#pragma option pop

class PASCALIMPLEMENTATION TAdvSmoothListBoxHeaderFooter : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	Graphics::TFont* FFont;
	AnsiString FCaption;
	int FHeight;
	Classes::TNotifyEvent FOnChange;
	bool FVisible;
	int FCaptionTop;
	int FCaptionLeft;
	Gdipfill::TGDIPFill* FFill;
	Graphics::TColor FCaptionShadowColor;
	TAdvSmoothListBoxCaptionLocation FCaptionLocation;
	Graphics::TColor FCaptionURLColor;
	int FCaptionShadowOffset;
	void __fastcall SetCaption(const AnsiString Value);
	void __fastcall SetFont(const Graphics::TFont* Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetCaptionLeft(const int Value);
	void __fastcall SetCaptionTop(const int Value);
	void __fastcall SetFill(const Gdipfill::TGDIPFill* Value);
	void __fastcall SetHeight(const int Value);
	void __fastcall SetCaptionLocation(const TAdvSmoothListBoxCaptionLocation Value);
	void __fastcall SetCaptionShadowColor(const Graphics::TColor Value);
	void __fastcall SetCaptionShadowOffset(const int Value);
	void __fastcall SetCaptionURLColor(const Graphics::TColor Value);
	
public:
	void __fastcall Changed(void);
	void __fastcall FontChanged(System::TObject* Sender);
	void __fastcall FillChanged(System::TObject* Sender);
	__fastcall TAdvSmoothListBoxHeaderFooter(TAdvSmoothListBox* AOwner);
	__fastcall virtual ~TAdvSmoothListBoxHeaderFooter(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	int __fastcall GetHeight(void);
	AnsiString __fastcall GetAnchorAt(const Types::TRect &r, int X, int Y);
	
__published:
	__property Gdipfill::TGDIPFill* Fill = {read=FFill, write=SetFill};
	__property int Height = {read=FHeight, write=SetHeight, default=40};
	__property AnsiString Caption = {read=FCaption, write=SetCaption};
	__property Graphics::TColor CaptionURLColor = {read=FCaptionURLColor, write=SetCaptionURLColor, default=16711680};
	__property Graphics::TColor CaptionShadowColor = {read=FCaptionShadowColor, write=SetCaptionShadowColor, default=8421504};
	__property int CaptionShadowOffset = {read=FCaptionShadowOffset, write=SetCaptionShadowOffset, default=5};
	__property TAdvSmoothListBoxCaptionLocation CaptionLocation = {read=FCaptionLocation, write=SetCaptionLocation, default=4};
	__property int CaptionLeft = {read=FCaptionLeft, write=SetCaptionLeft, default=0};
	__property int CaptionTop = {read=FCaptionTop, write=SetCaptionTop, default=0};
	__property Graphics::TFont* Font = {read=FFont, write=SetFont};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
};


class DELPHICLASS TAdvSmoothListBoxIndicator;
class PASCALIMPLEMENTATION TAdvSmoothListBoxIndicator : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	Advsmoothgdip::TAdvGradientType FGradientType;
	Byte FOpacity;
	Advsmoothgdip::HatchStyle FHatchStyle;
	Graphics::TColor FColor;
	Graphics::TColor FColorTo;
	bool FVisible;
	bool FFade;
	Classes::TNotifyEvent FOnChange;
	int FWidth;
	int FHeight;
	int FAnimateOpacity;
	void __fastcall SetColor(const Graphics::TColor Value);
	void __fastcall SetColorTo(const Graphics::TColor Value);
	void __fastcall SetGradientType(const Advsmoothgdip::TAdvGradientType Value);
	void __fastcall SetHatchStyle(const Advsmoothgdip::HatchStyle Value);
	void __fastcall SetOpacity(const Byte Value);
	void __fastcall SetVisible(const bool Value);
	void __fastcall SetFade(const bool Value);
	void __fastcall Setwidth(const int Value);
	
protected:
	void __fastcall Changed(void);
	
public:
	__fastcall TAdvSmoothListBoxIndicator(TAdvSmoothListBox* AOwner);
	__fastcall virtual ~TAdvSmoothListBoxIndicator(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	Byte __fastcall GetAnimationOpacity(void);
	int __fastcall GetWidth(void);
	
__published:
	__property bool Visible = {read=FVisible, write=SetVisible, default=1};
	__property Graphics::TColor Color = {read=FColor, write=SetColor, default=0};
	__property Graphics::TColor ColorTo = {read=FColorTo, write=SetColorTo, default=8421504};
	__property Byte Opacity = {read=FOpacity, write=SetOpacity, default=100};
	__property Advsmoothgdip::TAdvGradientType GradientType = {read=FGradientType, write=SetGradientType, default=0};
	__property Advsmoothgdip::HatchStyle HatchStyle = {read=FHatchStyle, write=SetHatchStyle, default=0};
	__property bool Fade = {read=FFade, write=SetFade, default=1};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
	__property int Width = {read=FWidth, write=Setwidth, default=5};
};


#pragma option push -b-
enum TAdvSmoothListBoxDetailStatus { dsDetailsNotVisible, dsDetailsVisible };
#pragma option pop

typedef void __fastcall (__closure *TAdvSmoothListBoxItemClickEvent)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxScrollEvent)(System::TObject* Sender, double CurrentPosition, double EndPosition);

typedef void __fastcall (__closure *TAdvSmoothListBoxDetailEvent)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemDrawEvent)(System::TObject* Sender, Graphics::TCanvas* Canvas, int itemindex, const Types::TRect &itemrect, bool &defaultdraw);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemTextEvent)(System::TObject* Sender, int itemindex, AnsiString &itemcaption, AnsiString &iteminfo, AnsiString &itemnotes);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemBkgDrawEvent)(System::TObject* Sender, Graphics::TCanvas* Canvas, int itemindex, const Types::TRect &itemRect, bool &defaultdraw);

typedef void __fastcall (__closure *TAdvSmoothListBoxAnchorClickEvent)(System::TObject* Sender, AnsiString Anchor);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemCheckedEvent)(System::TObject* Sender, int itemindex, bool checked);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemCaptionClick)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemInfoClick)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemAnchorClickEvent)(System::TObject* Sender, AnsiString Anchor, int ItemIndex);

#pragma option push -b-
enum TAdvSmoothListBoxSelectionMode { sPersistSelection, sAutoDeselect };
#pragma option pop

typedef void __fastcall (__closure *TAdvSmoothListBoxItemMouseEvent)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemHintEvent)(System::TObject* Sender, int itemindex, AnsiString &hint);

typedef void __fastcall (__closure *TAdvSmoothListBoxLookUpClickEvent)(System::TObject* Sender, int lookupindex, AnsiString lookupvalue);

typedef void __fastcall (__closure *TAdvSmoothListBoxHeaderClickEvent)(System::TObject* Sender, int X, int Y);

typedef void __fastcall (__closure *TAdvSmoothListBoxFooterClickEvent)(System::TObject* Sender, int X, int Y);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemSelectedEvent)(System::TObject* Sender, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemSelectionChangedEvent)(System::TObject* Sender, int previousitemindex, int itemindex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemDragStartEvent)(System::TObject* Sender, int DragItemIndex, bool &allowdrag);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemDragEndEvent)(System::TObject* Sender, int DragItemIndex);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemDragDropEvent)(System::TObject* Sender, int DragItemIndex, int DropItemIndex, bool &allowdrop);

typedef void __fastcall (__closure *TAdvSmoothListBoxItemDragOverEvent)(System::TObject* Sender, int DragItemIndex, int DropItemIndex);

class PASCALIMPLEMENTATION TAdvSmoothListBox : public Controls::TCustomControl 
{
	typedef Controls::TCustomControl inherited;
	
private:
	TAdvSmoothListBoxItem* FSelectedDragItem;
	TDragMode FMode;
	Forms::TForm* FDragItemForm;
	int FDragAnimateDelta;
	int FDragDelta;
	int FDragClickY;
	int FDragOldTop;
	int FPrevHoveredItemIndex;
	int FhoveredItemIndex;
	int FTimerCount;
	bool FDesignTime;
	bool FFocused;
	Controls::TControl* FCurrentControl;
	AnsiString FLookupKey;
	Graphics::TBitmap* FAnimateBitmap;
	int FClickX;
	int FClickY;
	bool FLookUp;
	int FLookUpSize;
	double FSp;
	int FTimeStart;
	int FTimeStop;
	bool FDetailShow;
	bool FAnimatingdetail;
	bool FAnimatingScroll;
	bool FMouseUp;
	bool FAnimating;
	bool FAnimate;
	bool FMouseDown;
	int FDetailIndex;
	int FDragY;
	int FScrollY;
	Extctrls::TTimer* FSmoothTimer;
	Extctrls::TTimer* FDragTimer;
	int FScPosTo;
	int FCurrentScPos;
	int FSelectedItemIndex;
	int FFocusedItemIndex;
	TAdvSmoothListBoxItems* FItems;
	TAdvSmoothListBoxDisplayList* FDisplayList;
	TAdvSmoothListBoxItemAppearance* FItemAppearance;
	TAdvSmoothListBoxLookUpBar* FLookUpBar;
	int FSpeedFactor;
	bool FSorted;
	TAdvSmoothListBoxSections* FSections;
	TAdvSmoothListBoxHeaderFooter* FHeader;
	TAdvSmoothListBoxIndicator* FScrollIndicator;
	TAdvSmoothListBoxHeaderFooter* FFooter;
	Controls::TControl* FControl;
	TAdvSmoothListBoxDetailStatus FDetailStatus;
	TAdvSmoothListBoxItemClickEvent FOnItemDblClick;
	TAdvSmoothListBoxItemClickEvent FOnItemClick;
	bool FKeyBoardLookup;
	int FSplitterHeight;
	TAdvSmoothListBoxScrollEvent FOnScroll;
	TAdvSmoothListBoxDetailEvent FOnShowDetail;
	TAdvSmoothListBoxDetailEvent FOnHideDetail;
	TAdvSmoothListBoxItemDrawEvent FOnItemDraw;
	TAdvSmoothListBoxItemTextEvent FOnItemText;
	TAdvSmoothListBoxItemBkgDrawEvent FOnItemBkgDraw;
	Gdippicturecontainer::TGDIPPictureContainer* FContainer;
	TAdvSmoothListBoxAnchorClickEvent FOnAnchorClick;
	TAdvSmoothListBoxShowDetailKey FShowDetailKey;
	TAdvSmoothListBoxShowDetailClick FShowDetailClick;
	Gdipfill::TGDIPFill* FFill;
	bool FShowFocus;
	Graphics::TColor FFocusColor;
	TAdvSmoothListBoxItems* FDefaultItems;
	TAdvSmoothListBoxItem* FDefaultItem;
	Imglist::TCustomImageList* FImages;
	bool FIsWinXP;
	Advsmoothgdip::TAdvGDIPPicture* FDetailItemImage;
	Advsmoothgdip::TAdvGDIPPicture* FItemImage;
	TAdvSmoothListBoxItemCheckedEvent FOnItemRadioClick;
	TAdvSmoothListBoxItemCheckedEvent FOnItemCheckClick;
	TAdvSmoothListBoxItemClickEvent FOnItemImageClick;
	TAdvSmoothListBoxItemCaptionClick FOnItemCaptionClick;
	TAdvSmoothListBoxItemInfoClick FOnItemInfoClick;
	TAdvSmoothListBoxItemAnchorClickEvent FOnItemAnchorClick;
	TAdvSmoothListBoxSelectionMode FSelectionMode;
	TAdvSmoothListBoxItemMouseEvent FOnItemMouseLeave;
	TAdvSmoothListBoxItemMouseEvent FOnItemMouseEnter;
	TAdvSmoothListBoxItemHintEvent FOnItemHint;
	TAdvSmoothListBoxLookUpClickEvent FOnLookUpClick;
	TAdvSmoothListBoxHeaderClickEvent FOnHeaderClick;
	TAdvSmoothListBoxFooterClickEvent FOnFooterClick;
	TAdvSmoothListBoxItemSelectedEvent FOnItemSelected;
	TAdvSmoothListBoxItemSelectionChangedEvent FOnItemSelectionChanged;
	bool FDragAlphaBlend;
	Byte FDragOpacity;
	int FDragBorderWidth;
	Graphics::TColor FDragBorderColor;
	TAdvSmoothListBoxItemDragStartEvent FOnItemDragStart;
	TAdvSmoothListBoxItemDragEndEvent FOnItemDragEnd;
	bool FItemDragging;
	bool FMultiSelect;
	TAdvSmoothListBoxItemDragDropEvent FOnItemDragDrop;
	TAdvSmoothListBoxItemDragOverEvent FOnItemDragOver;
	TAdvSmoothListBoxCategoryItems* FCategories;
	TAdvSmoothListBoxCategoryType FCategoryType;
	HIDESBASE MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMHintShow(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
	AnsiString __fastcall GetVersion();
	void __fastcall SetItems(const TAdvSmoothListBoxItems* Value);
	void __fastcall SetItemAppearance(const TAdvSmoothListBoxItemAppearance* Value);
	void __fastcall SetLookUpBar(const TAdvSmoothListBoxLookUpBar* Value);
	void __fastcall SetSpeedFactor(const int Value);
	void __fastcall SetSorted(const bool Value);
	void __fastcall SetSections(const TAdvSmoothListBoxSections* Value);
	void __fastcall SetHeader(const TAdvSmoothListBoxHeaderFooter* Value);
	void __fastcall SetScrollIndicator(const TAdvSmoothListBoxIndicator* Value);
	void __fastcall SetFooter(const TAdvSmoothListBoxHeaderFooter* Value);
	void __fastcall SetControl(const Controls::TControl* Value);
	void __fastcall SetKeyBoardLookup(const bool Value);
	void __fastcall SetSplitterHeight(const int Value);
	void __fastcall SetShowDetailClick(const TAdvSmoothListBoxShowDetailClick Value);
	void __fastcall SetShowDetailKey(const TAdvSmoothListBoxShowDetailKey Value);
	void __fastcall SetFill(const Gdipfill::TGDIPFill* Value);
	void __fastcall SetShowFocus(const bool Value);
	void __fastcall SetFocusColor(const Graphics::TColor Value);
	void __fastcall SetDefaultItem(const TAdvSmoothListBoxItem* Value);
	void __fastcall SetDetailItemImage(const Advsmoothgdip::TAdvGDIPPicture* Value);
	void __fastcall SetItemImage(const Advsmoothgdip::TAdvGDIPPicture* Value);
	int __fastcall GetSelectedItemIndex(void);
	void __fastcall SetSelectedItemIndex(const int Value);
	void __fastcall SetSelectionMode(const TAdvSmoothListBoxSelectionMode Value);
	void __fastcall SetDragAlphaBlend(const bool Value);
	void __fastcall SetDragOpacity(const Byte Value);
	void __fastcall SetDragBorderColor(const Graphics::TColor Value);
	void __fastcall SetDragBorderWidth(const int Value);
	void __fastcall SetItemDragging(const bool Value);
	void __fastcall SetMultiSelect(const bool Value);
	void __fastcall SetCategories(const TAdvSmoothListBoxCategoryItems* Value);
	void __fastcall SetCategoryType(const TAdvSmoothListBoxCategoryType Value);
	
protected:
	virtual void __fastcall Paint(void);
	virtual void __fastcall CreateParams(Controls::TCreateParams &params);
	void __fastcall CategoriesChanged(System::TObject* Sender);
	void __fastcall ItemsChanged(System::TObject* Sender);
	void __fastcall ScrollIndicatorChanged(System::TObject* Sender);
	void __fastcall AppearanceChanged(System::TObject* Sender);
	void __fastcall LookupBarChanged(System::TObject* Sender);
	void __fastcall HeaderFooterChanged(System::TObject* Sender);
	void __fastcall ItemAppearanceChanged(System::TObject* Sender);
	void __fastcall SectionsChanged(System::TObject* Sender);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation AOperation);
	void __fastcall DoItemDblClick(System::TObject* Sender, int itemindex);
	void __fastcall DoItemClick(System::TObject* Sender, int itemindex);
	void __fastcall DoItemImageClick(System::TObject* Sender, int itemindex);
	void __fastcall DoItemCheckClick(System::TObject* Sender, int itemindex, bool checked);
	void __fastcall DoItemRadioClick(System::TObject* Sender, int itemindex, bool checked);
	void __fastcall DoScroll(System::TObject* Sender, double CurrentPosition, double EndPosition);
	void __fastcall DoHideDetail(System::TObject* Sender, int itemindex);
	void __fastcall DoShowDetail(System::TObject* Sender, int itemindex);
	void __fastcall DoItemText(System::TObject* Sender, int itemindex, AnsiString &itemcaption, AnsiString &iteminfo, AnsiString &itemnotes);
	void __fastcall DoItemBkgDraw(System::TObject* Sender, Graphics::TCanvas* Canvas, int itemindex, const Types::TRect &itemrect, bool &defaultdraw);
	void __fastcall DoItemDraw(System::TObject* Sender, Graphics::TCanvas* Canvas, int itemindex, const Types::TRect &itemrect, bool &defaultdraw);
	void __fastcall DoAnchorClick(System::TObject* Sender, AnsiString Anchor);
	void __fastcall DoItemAnchorClick(System::TObject* Sender, AnsiString Anchor, int ItemIndex);
	void __fastcall DoItemCaptionClick(System::TObject* Sender, int itemindex);
	void __fastcall DoItemInfoClick(System::TObject* Sender, int itemindex);
	void __fastcall DrawBackground(void);
	void __fastcall DrawHeaderFooter(TAdvSmoothListBoxHeaderFooter* Part, bool Header);
	void __fastcall DrawItems(void);
	void __fastcall DrawLookUpBar(void);
	void __fastcall DrawScrollIndicator(void);
	void __fastcall DrawSection(const Types::TRect &itemRect, AnsiString ch, int catindex);
	HIDESBASE void __fastcall Changed(void);
	DYNAMIC void __fastcall Click(void);
	virtual void __fastcall CreateWnd(void);
	DYNAMIC void __fastcall MouseDown(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall MouseUp(Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
	DYNAMIC void __fastcall KeyPress(char &Key);
	DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
	DYNAMIC void __fastcall DoEnter(void);
	DYNAMIC void __fastcall DoExit(void);
	MESSAGE void __fastcall WMGetDlgCode(Messages::TWMNoParams &Message);
	DYNAMIC void __fastcall DblClick(void);
	DYNAMIC void __fastcall Resize(void);
	void __fastcall AnimateSmoothPos(System::TObject* Sender);
	void __fastcall DragSmoothPos(System::TObject* Sender);
	void __fastcall InitDisplayList(void);
	void __fastcall InitPreview(void);
	void __fastcall AddDisplaySection(TAdvSmoothListBoxItem* Item, Types::TRect &prevrect, int height, int lookup);
	void __fastcall AddDisplayItem(TAdvSmoothListBoxItem* Item, Types::TRect &prevrect, int height, int lookup);
	void __fastcall GetTextPosition(int &x, int &y, const Advsmoothgdip::TGPRectF &rectangle, int objectwidth, int objectheight, TAdvSmoothListBoxLocation location);
	int __fastcall GetVersionNr(void);
	int __fastcall GetPositionTo(void);
	int __fastcall GetPosition(void);
	int __fastcall GetShadowOffset(void);
	Types::TRect __fastcall GetHeaderFooterCaptionRect(TAdvSmoothListBoxHeaderFooter* Part, bool Header);
	Types::TRect __fastcall GetHeaderFooterRect(TAdvSmoothListBoxHeaderFooter* Part, bool Header);
	virtual bool __fastcall ItemFromDifferentCategory(TAdvSmoothListBoxItem* item1, TAdvSmoothListBoxItem* item2);
	TAdvSmoothListBoxDisplayListItem* __fastcall FindFirstItemWithChar(AnsiString ch);
	TAdvSmoothListBoxDisplayListItem* __fastcall FindFirstSectionWithChar(AnsiString ch);
	TAdvSmoothListBoxDisplayListItem* __fastcall FindFirstItemWithCategoryID(int CategoryID);
	TAdvSmoothListBoxDisplayListItem* __fastcall FindFirstSectionWithCategoryID(int CategoryID);
	Types::TRect __fastcall InsideRect();
	virtual int __fastcall GetFullHeight(void);
	virtual int __fastcall GetFullWidth(void);
	Types::TRect __fastcall GetDisplayRect();
	int __fastcall GetMaximumCustomTextWidth(Graphics::TCanvas* ACanvas);
	int __fastcall GetMaximumCustomTextHeight(Graphics::TCanvas* ACanvas);
	
public:
	DYNAMIC void __fastcall MouseWheelHandler(Messages::TMessage &Message);
	__fastcall virtual TAdvSmoothListBox(Classes::TComponent* AOwner);
	__fastcall virtual ~TAdvSmoothListBox(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall ShowDetails(void);
	void __fastcall HideDetails(void);
	__property TAdvSmoothListBoxDetailStatus DetailStatus = {read=FDetailStatus, nodefault};
	int __fastcall YToItem(int X, int Y, bool CountSections = false);
	int __fastcall ItemAtXY(int X, int Y);
	int __fastcall GetTopIndex(void);
	int __fastcall GetBottomIndex(void);
	void __fastcall ScrollToItem(int ItemIndex);
	void __fastcall SetComponentStyle(Advstyleif::TTMSStyle AStyle);
	
__published:
	__property AnsiString Version = {read=GetVersion};
	__property Gdipfill::TGDIPFill* Fill = {read=FFill, write=SetFill};
	__property Imglist::TCustomImageList* Images = {read=FImages, write=FImages};
	__property TAdvSmoothListBoxItems* Items = {read=FItems, write=SetItems};
	__property TAdvSmoothListBoxItemAppearance* ItemAppearance = {read=FItemAppearance, write=SetItemAppearance};
	__property int SplitterHeight = {read=FSplitterHeight, write=SetSplitterHeight, default=20};
	__property TAdvSmoothListBoxLookUpBar* LookupBar = {read=FLookUpBar, write=SetLookUpBar};
	__property int SpeedFactor = {read=FSpeedFactor, write=SetSpeedFactor, default=4};
	__property bool Sorted = {read=FSorted, write=SetSorted, default=0};
	__property TAdvSmoothListBoxSections* Sections = {read=FSections, write=SetSections};
	__property int SelectedItemIndex = {read=GetSelectedItemIndex, write=SetSelectedItemIndex, nodefault};
	__property TAdvSmoothListBoxHeaderFooter* Header = {read=FHeader, write=SetHeader};
	__property TAdvSmoothListBoxHeaderFooter* Footer = {read=FFooter, write=SetFooter};
	__property TAdvSmoothListBoxIndicator* ScrollIndicator = {read=FScrollIndicator, write=SetScrollIndicator};
	__property Controls::TControl* DetailControl = {read=FControl, write=SetControl};
	__property bool KeyBoardLookup = {read=FKeyBoardLookup, write=SetKeyBoardLookup, default=0};
	__property Gdippicturecontainer::TGDIPPictureContainer* PictureContainer = {read=FContainer, write=FContainer};
	__property TAdvSmoothListBoxShowDetailClick ShowDetailClick = {read=FShowDetailClick, write=SetShowDetailClick, default=0};
	__property TAdvSmoothListBoxShowDetailKey ShowDetailKey = {read=FShowDetailKey, write=SetShowDetailKey, default=0};
	__property TAdvSmoothListBoxHeaderClickEvent OnHeaderClick = {read=FOnHeaderClick, write=FOnHeaderClick};
	__property TAdvSmoothListBoxFooterClickEvent OnFooterClick = {read=FOnFooterClick, write=FOnFooterClick};
	__property TAdvSmoothListBoxItemDragStartEvent OnItemDragStart = {read=FOnItemDragStart, write=FOnItemDragStart};
	__property TAdvSmoothListBoxItemDragEndEvent OnItemDragEnd = {read=FOnItemDragEnd, write=FOnItemDragEnd};
	__property TAdvSmoothListBoxItemDragOverEvent OnItemDragOver = {read=FOnItemDragOver, write=FOnItemDragOver};
	__property TAdvSmoothListBoxItemDragDropEvent OnItemDragDrop = {read=FOnItemDragDrop, write=FOnItemDragDrop};
	__property TAdvSmoothListBoxItemMouseEvent OnItemMouseLeave = {read=FOnItemMouseLeave, write=FOnItemMouseLeave};
	__property TAdvSmoothListBoxItemMouseEvent OnItemMouseEnter = {read=FOnItemMouseEnter, write=FOnItemMouseEnter};
	__property TAdvSmoothListBoxLookUpClickEvent OnLookUpClick = {read=FOnLookUpClick, write=FOnLookUpClick};
	__property TAdvSmoothListBoxItemHintEvent OnItemHint = {read=FOnItemHint, write=FOnItemHint};
	__property TAdvSmoothListBoxItemClickEvent OnItemDblClick = {read=FOnItemDblClick, write=FOnItemDblClick};
	__property TAdvSmoothListBoxItemClickEvent OnItemClick = {read=FOnItemClick, write=FOnItemClick};
	__property TAdvSmoothListBoxItemSelectionChangedEvent OnItemSelectionChanged = {read=FOnItemSelectionChanged, write=FOnItemSelectionChanged};
	__property TAdvSmoothListBoxItemSelectedEvent OnItemSelected = {read=FOnItemSelected, write=FOnItemSelected};
	__property TAdvSmoothListBoxItemCheckedEvent OnItemCheckClick = {read=FOnItemCheckClick, write=FOnItemCheckClick};
	__property TAdvSmoothListBoxItemCheckedEvent OnItemRadioClick = {read=FOnItemRadioClick, write=FOnItemRadioClick};
	__property TAdvSmoothListBoxItemClickEvent OnItemImageClick = {read=FOnItemImageClick, write=FOnItemImageClick};
	__property TAdvSmoothListBoxScrollEvent OnScroll = {read=FOnScroll, write=FOnScroll};
	__property TAdvSmoothListBoxDetailEvent OnHideDetail = {read=FOnHideDetail, write=FOnHideDetail};
	__property TAdvSmoothListBoxDetailEvent OnShowDetail = {read=FOnShowDetail, write=FOnShowDetail};
	__property TAdvSmoothListBoxItemDrawEvent OnItemDraw = {read=FOnItemDraw, write=FOnItemDraw};
	__property TAdvSmoothListBoxItemBkgDrawEvent OnItemBkgDraw = {read=FOnItemBkgDraw, write=FOnItemBkgDraw};
	__property TAdvSmoothListBoxItemTextEvent OnItemText = {read=FOnItemText, write=FOnItemText};
	__property TAdvSmoothListBoxAnchorClickEvent OnAnchorClick = {read=FOnAnchorClick, write=FOnAnchorClick};
	__property TAdvSmoothListBoxItemAnchorClickEvent OnItemAnchorClick = {read=FOnItemAnchorClick, write=FOnItemAnchorClick};
	__property TAdvSmoothListBoxItemCaptionClick OnItemCaptionClick = {read=FOnItemCaptionClick, write=FOnItemCaptionClick};
	__property TAdvSmoothListBoxItemInfoClick OnItemInfoClick = {read=FOnItemInfoClick, write=FOnItemInfoClick};
	__property bool ShowFocus = {read=FShowFocus, write=SetShowFocus, default=1};
	__property Graphics::TColor FocusColor = {read=FFocusColor, write=SetFocusColor, default=0};
	__property Byte DragOpacity = {read=FDragOpacity, write=SetDragOpacity, default=200};
	__property bool DragAlphaBlend = {read=FDragAlphaBlend, write=SetDragAlphaBlend, default=1};
	__property int DragBorderWidth = {read=FDragBorderWidth, write=SetDragBorderWidth, default=1};
	__property Graphics::TColor DragBorderColor = {read=FDragBorderColor, write=SetDragBorderColor, default=0};
	__property TAdvSmoothListBoxItem* DefaultItem = {read=FDefaultItem, write=SetDefaultItem};
	__property Advsmoothgdip::TAdvGDIPPicture* ItemImage = {read=FItemImage, write=SetItemImage};
	__property Advsmoothgdip::TAdvGDIPPicture* DetailItemImage = {read=FDetailItemImage, write=SetDetailItemImage};
	__property TAdvSmoothListBoxSelectionMode SelectionMode = {read=FSelectionMode, write=SetSelectionMode, default=1};
	__property bool ItemDragging = {read=FItemDragging, write=SetItemDragging, default=1};
	__property bool MultiSelect = {read=FMultiSelect, write=SetMultiSelect, default=0};
	__property TAdvSmoothListBoxCategoryType CategoryType = {read=FCategoryType, write=SetCategoryType, default=0};
	__property TAdvSmoothListBoxCategoryItems* Categories = {read=FCategories, write=SetCategories};
	__property Align  = {default=0};
	__property Anchors  = {default=3};
	__property Constraints ;
	__property PopupMenu ;
	__property TabOrder  = {default=-1};
	__property ParentShowHint  = {default=1};
	__property ShowHint ;
	__property OnKeyDown ;
	__property OnKeyPress ;
	__property OnMouseUp ;
	__property OnMouseMove ;
	__property OnMouseDown ;
	__property OnMouseActivate ;
	__property OnMouseEnter ;
	__property OnMouseLeave ;
	__property OnResize ;
	__property OnDblClick ;
	__property OnClick ;
	__property OnEnter ;
	__property OnExit ;
	__property OnDragDrop ;
	__property OnDragOver ;
	__property OnStartDrag ;
	__property OnEndDrag ;
	__property Visible  = {default=1};
	__property TabStop  = {default=0};
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TAdvSmoothListBox(HWND ParentWindow) : Controls::TCustomControl(ParentWindow) { }
	#pragma option pop
	
private:
	void *__ITMSStyle;	/* Advstyleif::ITMSStyle */
	
public:
	operator ITMSStyle*(void) { return (ITMSStyle*)&__ITMSStyle; }
	
};


class PASCALIMPLEMENTATION TAdvSmoothListBoxItemAppearance : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	int FSpacingVert;
	int FSpacingHorz;
	int FItemHeight;
	Classes::TNotifyEvent FOnChange;
	Gdipfill::TGDIPFill* FFill;
	Gdipfill::TGDIPFill* FFillDisabled;
	Gdipfill::TGDIPFill* FFillSelected;
	void __fastcall SetItemHeight(const int Value);
	void __fastcall SetSpacingHorz(const int Value);
	void __fastcall SetSpacingVert(const int Value);
	void __fastcall SetFill(const Gdipfill::TGDIPFill* Value);
	void __fastcall SetFillDisabled(const Gdipfill::TGDIPFill* Value);
	void __fastcall SetFillSelected(const Gdipfill::TGDIPFill* Value);
	
protected:
	void __fastcall Changed(void);
	void __fastcall FontChanged(System::TObject* Sender);
	void __fastcall FillChanged(System::TObject* Sender);
	
public:
	__fastcall TAdvSmoothListBoxItemAppearance(TAdvSmoothListBox* AOwner);
	__fastcall virtual ~TAdvSmoothListBoxItemAppearance(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property Gdipfill::TGDIPFill* Fill = {read=FFill, write=SetFill};
	__property Gdipfill::TGDIPFill* FillSelected = {read=FFillSelected, write=SetFillSelected};
	__property Gdipfill::TGDIPFill* FillDisabled = {read=FFillDisabled, write=SetFillDisabled};
	__property int VerticalSpacing = {read=FSpacingVert, write=SetSpacingVert, default=0};
	__property int HorizontalSpacing = {read=FSpacingHorz, write=SetSpacingHorz, default=0};
	__property int Height = {read=FItemHeight, write=SetItemHeight, default=30};
	__property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
};


#pragma option push -b-
enum TAdvSmoothListBoxItemKind { ikItem, ikSection };
#pragma option pop

class PASCALIMPLEMENTATION TAdvSmoothListBoxCategoryItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TAdvSmoothListBox* FOwner;
	AnsiString FText;
	int FID;
	int FTag;
	int FImageIndex;
	AnsiString FLookupText;
	void __fastcall SetText(const AnsiString Value);
	void __fastcall SetId(const int Value);
	void __fastcall SetImageIndex(const int Value);
	void __fastcall SetTag(const int Value);
	void __fastcall SetLookupText(const AnsiString Value);
	
protected:
	HIDESBASE void __fastcall Changed(void);
	
public:
	__fastcall virtual TAdvSmoothListBoxCategoryItem(Classes::TCollection* Collection);
	__fastcall virtual ~TAdvSmoothListBoxCategoryItem(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int ImageIndex = {read=FImageIndex, write=SetImageIndex, default=-1};
	__property int Tag = {read=FTag, write=SetTag, nodefault};
	__property AnsiString Text = {read=FText, write=SetText};
	__property AnsiString LookupText = {read=FLookupText, write=SetLookupText};
	__property int Id = {read=FID, write=SetId, nodefault};
};


typedef DynamicArray<bool >  AdvSmoothListBox__7;

class PASCALIMPLEMENTATION TAdvSmoothListBoxDisplayListItem : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	#pragma pack(push,1)
	Types::TRect FItemRect;
	#pragma pack(pop)
	bool FFloating;
	TAdvSmoothListBoxItemKind FKind;
	TAdvSmoothListBoxItem* FItem;
	AnsiString FSectionCaption;
	int FSectionCategoryID;
	void __fastcall SetFloating(const bool Value);
	void __fastcall SetKind(const TAdvSmoothListBoxItemKind Value);
	void __fastcall SetSectionCaption(const AnsiString Value);
	void __fastcall SetSectionCategoryID(const int Value);
	
protected:
	void __fastcall Changed(void);
	
public:
	__property TAdvSmoothListBoxItemKind Kind = {read=FKind, write=SetKind, nodefault};
	__property AnsiString SectionCaption = {read=FSectionCaption, write=SetSectionCaption};
	__property int SectionCategoryID = {read=FSectionCategoryID, write=SetSectionCategoryID, nodefault};
	__property bool Floating = {read=FFloating, write=SetFloating, nodefault};
	__property TAdvSmoothListBoxItem* DisplayItem = {read=FItem, write=FItem};
	__property Types::TRect ItemRect = {read=FItemRect, write=FItemRect};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TAdvSmoothListBoxDisplayListItem(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TAdvSmoothListBoxDisplayListItem(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
static const Shortint MAJ_VER = 0x1;
static const Shortint MIN_VER = 0x1;
static const Shortint REL_VER = 0x0;
static const Shortint BLD_VER = 0x0;

}	/* namespace Advsmoothlistbox */
using namespace Advsmoothlistbox;
#pragma pack(pop)
#pragma option pop

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