dbplanner.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) 'Dbplanner.pas' rev: 11.00

#ifndef DbplannerHPP
#define DbplannerHPP

#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 <Planner.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Db.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Graphics.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Comobj.hpp>	// Pascal unit
#include <Activex.hpp>	// Pascal unit
#include <Planrecurr.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit

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

namespace Dbplanner
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TResourceMapItem;
class PASCALIMPLEMENTATION TResourceMapItem : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	int FResourceIndex;
	int FPositionIndex;
	AnsiString FDisplayName;
	
public:
	__fastcall virtual TResourceMapItem(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	
__published:
	__property int ResourceIndex = {read=FResourceIndex, write=FResourceIndex, nodefault};
	__property int PositionIndex = {read=FPositionIndex, write=FPositionIndex, nodefault};
	__property AnsiString DisplayName = {read=FDisplayName, write=FDisplayName};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TResourceMapItem(void) { }
	#pragma option pop
	
};


class DELPHICLASS TResourceMap;
class PASCALIMPLEMENTATION TResourceMap : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TResourceMapItem* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TComponent* FOwner;
	HIDESBASE TResourceMapItem* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TResourceMapItem* Value);
	
public:
	HIDESBASE TResourceMapItem* __fastcall Add(void);
	HIDESBASE TResourceMapItem* __fastcall Insert(int index);
	__property TResourceMapItem* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	__fastcall TResourceMap(Classes::TComponent* AOwner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	int __fastcall ResToPosition(int Value);
	int __fastcall PositionToRes(int Value);
	AnsiString __fastcall PositionName(int Value);
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TResourceMap(void) { }
	#pragma option pop
	
};


class DELPHICLASS TResourceDataSource;
class DELPHICLASS TDBItemSource;
class DELPHICLASS TItemSource;
typedef void __fastcall (__closure *TCreateKeyEvent)(System::TObject* Sender, Planner::TPlannerItem* APlannerItem, AnsiString &Key);

typedef void __fastcall (__closure *TAcceptEvent)(System::TObject* Sender, Db::TFields* Fields, bool &Accept);

class PASCALIMPLEMENTATION TItemSource : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Planner::TPlanner* FPlanner;
	int FUpdateCount;
	TCreateKeyEvent FOnCreateKey;
	bool FActive;
	Classes::TNotifyEvent FOnSetFilter;
	Classes::TNotifyEvent FOnResetFilter;
	TAcceptEvent FOnAccept;
	int FLocateIdx;
	AnsiString FLocateSpecifier;
	Planner::TFindTextParams FLocateParams;
	void __fastcall SetPlanner(Planner::TPlanner* Value);
	void __fastcall SetActive(const bool Value);
	
public:
	virtual void __fastcall ClearDBItems(void);
	virtual void __fastcall ReadDBItems(AnsiString UpdateKey);
	virtual void __fastcall WriteDBItem(void);
	virtual void __fastcall ReadDBItem(void);
	virtual void __fastcall SynchDBItems(void);
	virtual void __fastcall AddDBItem(void);
	virtual void __fastcall GotoDBItem(void);
	virtual void __fastcall DeleteDBItem(Planner::TPlanner* APlanner);
	virtual void __fastcall ItemChanged(AnsiString DBKey);
	virtual void __fastcall Refresh(void);
	virtual void __fastcall Reload(void);
	virtual void __fastcall Next(void);
	virtual void __fastcall Prev(void);
	__fastcall virtual TItemSource(Classes::TComponent* AOwner);
	__fastcall virtual ~TItemSource(void);
	virtual void __fastcall PlannerChanged(void);
	__property Planner::TPlanner* Planner = {read=FPlanner, write=SetPlanner};
	void __fastcall BeginUpdate(void);
	void __fastcall EndUpdate(void);
	bool __fastcall IsUpdating(void);
	virtual AnsiString __fastcall CreateKey();
	virtual bool __fastcall LocateFirstItem(AnsiString Specifier, Planner::TFindTextParams Params, System::TDateTime &StartTime, System::TDateTime &EndTime, AnsiString &Key);
	virtual bool __fastcall LocateNextItem(System::TDateTime &StartTime, System::TDateTime &EndTime, AnsiString &Key);
	virtual System::TDateTime __fastcall PosToDay(int Pos);
	virtual int __fastcall PosToRes(int Pos);
	virtual void __fastcall MapItemTimeOnPlanner(Planner::TPlannerItem* APlannerItem);
	
__published:
	__property bool Active = {read=FActive, write=SetActive, default=1};
	__property TCreateKeyEvent OnCreateKey = {read=FOnCreateKey, write=FOnCreateKey};
	__property Classes::TNotifyEvent OnResetFilter = {read=FOnResetFilter, write=FOnResetFilter};
	__property Classes::TNotifyEvent OnSetFilter = {read=FOnSetFilter, write=FOnSetFilter};
	__property TAcceptEvent OnAccept = {read=FOnAccept, write=FOnAccept};
};


class DELPHICLASS TDBPlannerDataLink;
class PASCALIMPLEMENTATION TDBPlannerDataLink : public Db::TDataLink 
{
	typedef Db::TDataLink inherited;
	
private:
	TDBItemSource* FDBItemSource;
	
protected:
	virtual void __fastcall ActiveChanged(void);
	virtual void __fastcall DataSetChanged(void);
	virtual void __fastcall DataSetScrolled(int Distance);
	virtual void __fastcall RecordChanged(Db::TField* Field);
	
public:
	__fastcall TDBPlannerDataLink(TDBItemSource* ADBItemSource);
	__fastcall virtual ~TDBPlannerDataLink(void);
};


class DELPHICLASS TDBPlannerResourceDataLink;
class PASCALIMPLEMENTATION TDBPlannerResourceDataLink : public Db::TDataLink 
{
	typedef Db::TDataLink inherited;
	
private:
	TDBItemSource* FDBItemSource;
	int FUpdateCount;
	
protected:
	virtual void __fastcall ActiveChanged(void);
	virtual void __fastcall DataSetChanged(void);
	virtual void __fastcall RecordChanged(Db::TField* Field);
	void __fastcall UpdateResourceMap(void);
	
public:
	__fastcall TDBPlannerResourceDataLink(TDBItemSource* ADBItemSource);
	__fastcall virtual ~TDBPlannerResourceDataLink(void);
};


typedef void __fastcall (__closure *TFieldsItemEvent)(System::TObject* Sender, Db::TFields* Fields, Planner::TPlannerItem* Item);

typedef void __fastcall (__closure *TPosToResourceEvent)(System::TObject* Sender, Db::TField* Field, int Position);

typedef void __fastcall (__closure *TResourceToPosEvent)(System::TObject* Sender, Db::TField* Field, int &Position, bool &Accept);

typedef void __fastcall (__closure *TDBItemSQLEvent)(System::TObject* Sender, Planner::TPlannerItem* APlannerItem);

typedef void __fastcall (__closure *TFieldsToTimeEvent)(System::TObject* Sender, Db::TFields* Fields, System::TDateTime &dtS, System::TDateTime &dtE);

typedef void __fastcall (__closure *TTimeToFieldsEvent)(System::TObject* Sender, Db::TFields* Fields, System::TDateTime dtS, System::TDateTime dtE);

class PASCALIMPLEMENTATION TDBItemSource : public TItemSource 
{
	typedef TItemSource inherited;
	
private:
	AnsiString FEndTimeField;
	AnsiString FStartTimeField;
	AnsiString FKeyField;
	AnsiString FResourceField;
	AnsiString FSubjectField;
	AnsiString FNotesField;
	AnsiString FRecurrencyField;
	AnsiString FMinTimeField;
	AnsiString FMaxTimeField;
	bool FAutoIncKey;
	TDBPlannerDataLink* FDataLink;
	TDBPlannerResourceDataLink* FResourceDataLink;
	TFieldsItemEvent FOnFieldsToItem;
	TFieldsItemEvent FOnItemToFields;
	Classes::TNotifyEvent FOnChangeQuery;
	TPosToResourceEvent FOnPositionToResource;
	TResourceToPosEvent FOnResourceToPosition;
	bool FReadOnly;
	TDBItemSQLEvent FOnInsertItem;
	TDBItemSQLEvent FOnDeleteItem;
	TDBItemSQLEvent FOnUpdateItem;
	Classes::TNotifyEvent FOnItemsRead;
	Classes::TNotifyEvent FOnBeforeItemsRead;
	TFieldsToTimeEvent FOnFieldsToTime;
	TTimeToFieldsEvent FOnTimeToFields;
	bool FUpdateByQuery;
	TResourceMap* FResourceMap;
	Planrecurr::TRecurrencyHandler* FRecurrencyHandler;
	TResourceDataSource* FResourceDataSource;
	Classes::TNotifyEvent FOnResourceChange;
	Db::TDataSource* __fastcall GetDataSource(void);
	void __fastcall SetDataSource(const Db::TDataSource* Value);
	void __fastcall SetEndTimeField(const AnsiString Value);
	void __fastcall SetStartTimeField(const AnsiString Value);
	void __fastcall SetKeyField(const AnsiString Value);
	void __fastcall SetNotesField(const AnsiString Value);
	void __fastcall SetSubjectField(const AnsiString Value);
	void __fastcall SetResourceField(const AnsiString Value);
	void __fastcall SetRecurrencyField(const AnsiString Value);
	void __fastcall SetMinTimeField(const AnsiString Value);
	void __fastcall SetMaxTimeField(const AnsiString Value);
	void __fastcall SetReadOnly(const bool Value);
	void __fastcall SetResourceMap(const TResourceMap* Value);
	void __fastcall SetResourceDataSource(const TResourceDataSource* Value);
	
protected:
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation AOperation);
	bool __fastcall CheckDataSet(void);
	virtual void __fastcall MoveResource(int FromPos, int ToPos);
	virtual void __fastcall ResourceUpdate(void);
	
public:
	__fastcall virtual TDBItemSource(Classes::TComponent* AOwner);
	__fastcall virtual ~TDBItemSource(void);
	virtual void __fastcall Next(void);
	virtual void __fastcall Prev(void);
	virtual bool __fastcall LocateFirstItem(AnsiString Specifier, Planner::TFindTextParams Params, System::TDateTime &StartTime, System::TDateTime &EndTime, AnsiString &Key);
	virtual bool __fastcall LocateNextItem(System::TDateTime &StartTime, System::TDateTime &EndTime, AnsiString &Key);
	virtual void __fastcall FieldsToTime(Db::TFields* Fields, System::TDateTime &dtS, System::TDateTime &dtE);
	virtual void __fastcall TimeToFields(Db::TFields* Fields, System::TDateTime dtS, System::TDateTime dtE);
	virtual void __fastcall FieldsToRes(Db::TFields* Fields, int &Position, bool &Accept);
	virtual void __fastcall ResToFields(Db::TFields* Fields, int Position);
	__property AnsiString RecurrencyField = {read=FRecurrencyField, write=SetRecurrencyField};
	__property AnsiString MaxTimeField = {read=FMaxTimeField, write=SetMaxTimeField};
	__property AnsiString MinTimeField = {read=FMinTimeField, write=SetMinTimeField};
	
__published:
	__property bool AutoIncKey = {read=FAutoIncKey, write=FAutoIncKey, nodefault};
	__property Db::TDataSource* DataSource = {read=GetDataSource, write=SetDataSource};
	__property TResourceDataSource* ResourceDataSource = {read=FResourceDataSource, write=SetResourceDataSource};
	__property TResourceMap* ResourceMap = {read=FResourceMap, write=SetResourceMap};
	__property AnsiString StartTimeField = {read=FStartTimeField, write=SetStartTimeField};
	__property AnsiString EndTimeField = {read=FEndTimeField, write=SetEndTimeField};
	__property AnsiString KeyField = {read=FKeyField, write=SetKeyField};
	__property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, nodefault};
	__property AnsiString ResourceField = {read=FResourceField, write=SetResourceField};
	__property AnsiString SubjectField = {read=FSubjectField, write=SetSubjectField};
	__property AnsiString NotesField = {read=FNotesField, write=SetNotesField};
	__property bool UpdateByQuery = {read=FUpdateByQuery, write=FUpdateByQuery, nodefault};
	__property Classes::TNotifyEvent OnBeforeItemsRead = {read=FOnBeforeItemsRead, write=FOnBeforeItemsRead};