sctctrl.hpp

suite component ace report

// Borland C++ Builder
// Copyright (c) 1995, 1998 by Borland International
// All rights reserved

// (DO NOT EDIT: machine generated header) 'SctCtrl.pas' rev: 3.00

#ifndef SctCtrlHPP
#define SctCtrlHPP
#include <AceImg.hpp>
#include <AceMemoU.hpp>
#include <AceUtil.hpp>
#include <AceOut.hpp>
#include <SctUtil.hpp>
#include <SctRtf.hpp>
#include <SctData.hpp>
#include <SctVar.hpp>
#include <StdCtrls.hpp>
#include <Dialogs.hpp>
#include <Forms.hpp>
#include <Controls.hpp>
#include <Graphics.hpp>
#include <Classes.hpp>
#include <Messages.hpp>
#include <SysUtils.hpp>
#include <Windows.hpp>
#include <SysInit.hpp>
#include <System.hpp>

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

namespace Sctctrl
{
//-- type declarations -------------------------------------------------------
typedef Word TSctRotateFont;

enum TSctDirection { bdVertical, bdHorizontal };

enum TSctCheckStyle { csCross, csCheck };

enum TSctClipTypes { ctDefault, ctClip, ctNoClip };

enum TSctVerticalAlign { laTop, laMiddle, laBottom, laCenterVert };

enum TSctHorizontalAlign { laLeft, laCenter, laRight };

enum TSctBorderType { btNone, btSingle, btUnderLine };

enum TSctShapeType { sstCircle, sstEllipse, sstRectangle, sstRoundRect, sstRoundSquare, sstSquare };
	

class DELPHICLASS TSctLabel;
typedef void __fastcall (__closure *TSctLabelPrintWhenEvent)(TSctLabel* lb, bool &Result);

typedef void __fastcall (__closure *TSctLabelPrintEvent)(TSctLabel* lb);

typedef void __fastcall (__closure *TSctOnDrawEvent)(TSctLabel* lb, System::TObject* AceCanvas, const 
	Windows::TRect &Rect);

class PASCALIMPLEMENTATION TSctLabel : public Controls::TGraphicControl 
{
	typedef Controls::TGraphicControl inherited;
	
private:
	Controls::TWinControl* FPage;
	TSctClipTypes FClipType;
	TSctVerticalAlign FVerticalAlign;
	TSctHorizontalAlign FHorizontalAlign;
	bool FEndPrint;
	bool FFirstTime;
	bool FWrapText;
	bool FStretch;
	TSctBorderType FBorderType;
	Graphics::TBrush* FBrush;
	Graphics::TBrush* FBrushSet;
	Graphics::TPen* FPen;
	Graphics::TPen* FPenSet;
	Graphics::TPen* FBorderPen;
	int FPixelsPerInch;
	TSctLabelPrintWhenEvent FLabelPrintWhen;
	TSctLabelPrintEvent FOnBeforePrint;
	TSctLabelPrintEvent FOnAfterPrint;
	int FRow;
	bool FRtfPrint;
	TSctRotateFont FRotateFont;
	TAceShadePercent FShade;
	bool FPainting;
	int FBorderMargin;
	bool FAutoSize;
	void __fastcall AdjustBounds(void);
	bool __fastcall GetTransparent(void);
	void __fastcall SetAutoSize(bool Value);
	void __fastcall SetTransparent(bool Value);
	MESSAGE void __fastcall CMTextChanged(Messages::TMessage &Message);
	HIDESBASE MESSAGE void __fastcall CMFontChanged(Messages::TMessage &Message);
	void __fastcall SetBrush(Graphics::TBrush* Value);
	void __fastcall SetPen(Graphics::TPen* Value);
	MESSAGE void __fastcall MouseMovement(Messages::TWMMouse &Message);
	
protected:
	virtual void __fastcall SetParent(Controls::TWinControl* AParent);
	Controls::TWinControl* __fastcall getpage(void);
	bool __fastcall GetClipRect(void);
	Word __fastcall GetAlignFlags(void);
	int __fastcall GetXPos(void);
	int __fastcall GetYPos(void);
	virtual System::AnsiString __fastcall GetDataNow();
	virtual void __fastcall Paint(void);
	void __fastcall SetVerticalAlign(TSctVerticalAlign va);
	void __fastcall SetHorizontalAlign(TSctHorizontalAlign ha);
	virtual System::AnsiString __fastcall GetDisplayText();
	virtual void __fastcall SetBorderType(TSctBorderType BType);
	virtual void __fastcall SetWrapText(bool W);
	virtual void __fastcall SetStretch(bool S);
	int __fastcall GetPPI(void);
	bool __fastcall GetPrintOk(void);
	virtual void __fastcall Loaded(void);
	virtual void __fastcall SetRotateFont(TSctRotateFont Rotate);
	virtual void __fastcall SetShade(Aceutil::TAceShadePercent ShadePercent);
	void __fastcall SetBorderMargin(int bm);
	__property Graphics::TBrush* BrushSet = {read=FBrushSet, write=FBrushSet};
	__property Graphics::TPen* PenSet = {read=FPenSet, write=FPenSet};
	__property bool Painting = {read=FPainting, write=FPainting, nodefault};
	void __fastcall ReadAutoSize(Classes::TReader* Reader);
	void __fastcall WriteAutoSize(Classes::TWriter* Writer);
	
public:
	__property bool Transparent = {read=GetTransparent, write=SetTransparent, default=1};
	__property bool AutoSize = {read=FAutoSize, write=SetAutoSize, default=0};
	__property Canvas ;
	__fastcall virtual TSctLabel(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctLabel(void);
	virtual void __fastcall LabelChanged(System::TObject* Sender);
	virtual void __fastcall print(Classes::TComponent* oPage, int space);
	__property Controls::TWinControl* Page = {read=getpage, write=FPage};
	__property bool ClipRect = {read=GetClipRect, nodefault};
	__property Word AlignFlags = {read=GetAlignFlags, nodefault};
	__property int XPos = {read=GetXPos, nodefault};
	__property int YPos = {read=GetYPos, nodefault};
	__property System::AnsiString DataNow = {read=GetDataNow};
	__property TSctClipTypes ClipType = {read=FClipType, write=FClipType, default=0};
	__property TSctVerticalAlign AlignVertical = {read=FVerticalAlign, write=SetVerticalAlign, default=2
		};
	__property TSctHorizontalAlign AlignHorizontal = {read=FHorizontalAlign, write=SetHorizontalAlign, 
		default=0};
	__property System::AnsiString DisplayText = {read=GetDisplayText};
	__property bool EndPrint = {read=FEndPrint, write=FEndPrint, nodefault};
	__property bool FirstTime = {read=FFirstTime, write=FFirstTime, nodefault};
	virtual void __fastcall StartPrint(void);
	virtual int __fastcall PrintHeight(Classes::TComponent* oPage, int Space, int Taking);
	__property TSctBorderType BorderType = {read=FBorderType, write=SetBorderType, default=0};
	__property Graphics::TBrush* Brush = {read=FBrush, write=SetBrush};
	__property Graphics::TPen* Pen = {read=FPen, write=SetPen};
	__property Graphics::TPen* BorderPen = {read=FBorderPen, write=FBorderPen};
	__property bool WrapText = {read=FWrapText, write=SetWrapText, default=0};
	__property bool Stretch = {read=FStretch, write=SetStretch, default=0};
	__property int PixelsPerInch = {read=GetPPI, write=FPixelsPerInch, nodefault};
	virtual int __fastcall SpendHeight(Classes::TComponent* oPage, int Space);
	__property bool PrintOk = {read=GetPrintOk, nodefault};
	void __fastcall BeforePrint(void);
	void __fastcall AfterPrint(void);
	virtual void __fastcall PrintRtf(Controls::TWinControl* oPage, Sctrtf::TSctRtfFile* rtf, int PrintRow
		);
	virtual void __fastcall PrintTab(Controls::TWinControl* oPage, Sctrtf::TSctRtfFile* rtf, int PrintRow
		);
	int __fastcall GetXSpot(int x);
	int __fastcall GetYSpot(int y);
	void __fastcall InitPrint(Aceout::TAceCanvas* AceCanvas, const Windows::TRect &Rect);
	void __fastcall PrintBorder(Aceout::TAceCanvas* AceCanvas, const Windows::TRect &Rect);
	virtual void __fastcall PrintLabel(Aceout::TAceCanvas* AceCanvas, const Windows::TRect &Rect, int Space
		);
	__property TSctRotateFont RotateFont = {read=FRotateFont, write=SetRotateFont, default=0};
	__property Aceutil::TAceShadePercent Shade = {read=FShade, write=SetShade, default=0};
	__property int BorderMargin = {read=FBorderMargin, write=SetBorderMargin, default=2};
	__property Caption ;
	__property Color ;
	
__published:
	__property TSctLabelPrintWhenEvent LabelPrintWhen = {read=FLabelPrintWhen, write=FLabelPrintWhen};
	__property TSctLabelPrintEvent OnBeforePrint = {read=FOnBeforePrint, write=FOnBeforePrint};
	__property TSctLabelPrintEvent OnAfterPrint = {read=FOnAfterPrint, write=FOnAfterPrint};
	__property int Row = {read=FRow, write=FRow, default=0};
	__property bool RtfPrint = {read=FRtfPrint, write=FRtfPrint, default=1};
};

typedef Word TSctWrapHeightPercent;

class DELPHICLASS TSctTVLabel;
class PASCALIMPLEMENTATION TSctTVLabel : public Sctctrl::TSctLabel 
{
	typedef Sctctrl::TSctLabel inherited;
	
private:
	Sctvar::TSctVar* FVariable;
	int FDataRow;
	TSctWrapHeightPercent FWrapHeightPercent;
	Acememou::TAceMemo* FAceMemo;
	bool FJustifyMemo;
	Sctdata::TSctFormat* FDataFormat;
	bool FSuppressRepeats;
	Classes::TStrings* FLines;
	bool FSuppressBlankLines;
	bool FSuppressWhiteSpace;
	void __fastcall SetLines(Classes::TStrings* Value);
	
protected:
	virtual System::AnsiString __fastcall GetDisplayText();
	virtual void __fastcall Paint(void);
	void __fastcall SetWrapHeightPercent(TSctWrapHeightPercent whp);
	void __fastcall SetJustifyMemo(bool Value);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	
public:
	__fastcall virtual TSctTVLabel(Classes::TComponent* AOwner);
	__fastcall virtual ~TSctTVLabel(void);
	void __fastcall SetVariable(Sctvar::TSctVar* variable);
	virtual System::AnsiString __fastcall GetDataNow();
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
		);
	virtual void __fastcall Print(Classes::TComponent* oPage, int Space);
	virtual void __fastcall StartPrint(void);
	virtual int __fastcall PrintHeight(Classes::TComponent* oPage, int Space, int Taking);
	__property int DataRow = {read=FDataRow, write=FDataRow, nodefault};
	int __fastcall PrintMemo(Aceout::TAceCanvas* AceCanvas, const Windows::TRect &Rect, int Space);
	virtual int __fastcall SpendHeight(Classes::TComponent* oPage, int Space);
	int __fastcall SpendMemo(Classes::TComponent* oPage, int Space);
	virtual void __fastcall PrintRtf(Controls::TWinControl* oPage, Sctrtf::TSctRtfFile* rtf, int PrintRow
		);
	virtual void __fastcall PrintTab(Controls::TWinControl* oPage, Sctrtf::TSctRtfFile* rtf, int PrintRow
		);
	virtual void __fastcall PrintLabel(Aceout::TAceCanvas* AceCanvas, const Windows::TRect &Rect, int Space
		);
	virtual void __fastcall UpdateMemo(void);
	__property Acememou::TAceMemo* AceMemo = {read=FAceMemo, write=FAceMemo};
	bool __fastcall IsMemo(void);
	__property Sctvar::TSctVar* Variable = {read=FVariable, write=SetVariable};
	__property Sctdata::TSctFormat* DataFormat = {read=FDataFormat, write=FDataFormat};
	__property bool SuppressRepeats = {read=FSuppressRepeats, write=FSuppressRepeats, default=0};
	
__published:
	__property Align ;
	__property Color ;
	__property Font ;
	__property ParentColor ;
	__property ParentFont ;
	__property Transparent ;
	__property ClipType ;
	__property AlignVertical ;
	__property AlignHorizontal ;
	__property BorderType ;
	__property RotateFont ;
	__property Shade ;
	__property BorderMargin ;
	__property WrapText ;
	__property Stretch ;
	__property TSctWrapHeightPercent WrapHeightPercent = {read=FWrapHeightPercent, write=SetWrapHeightPercent
		, default=100};
	__property bool JustifyMemo = {read=FJustifyMemo, write=SetJustifyMemo, default=0};
	__property Classes::TStrings* Lines = {read=FLines, write=SetLines};
	__property bool SuppressBlankLines = {read=FSuppressBlankLines, write=FSuppressBlankLines, default=0
		};
	__property bool SuppressWhiteSpace = {read=FSuppressWhiteSpace, write=FSuppressWhiteSpace, default=0
		};
};

class DELPHICLASS TSctvarlabel;
class PASCALIMPLEMENTATION TSctvarlabel : public Sctctrl::TSctTVLabel 
{
	typedef Sctctrl::TSctTVLabel inherited;
	
__published:
	__property Variable ;
	__property DataFormat ;
	__property SuppressRepeats ;
	__property Caption ;
public:
	/* TSctTVLabel.Create */ __fastcall virtual TSctvarlabel(Classes::TComponent* AOwner) : Sctctrl::TSctTVLabel(
		AOwner) { }
	/* TSctTVLabel.Destroy */ __fastcall virtual ~TSctvarlabel(void) { }
	
};

class DELPHICLASS TSctTextLabel;
class PASCALIMPLEMENTATION TSctTextLabel : public Sctctrl::TSctTVLabel 
{
	typedef Sctctrl::TSctTVLabel inherited;
	
protected:
	virtual void __fastcall WriteState(Classes::TWriter* Writer);
	
__published:
	__property AutoSize ;
	__property Caption ;
public:
	/* TSctTVLabel.Create */ __fastcall virtual TSctTextLabel(Classes::TComponent* AOwner) : Sctctrl::TSctTVLabel(
		AOwner) { }
	/* TSctTVLabel.Destroy */ __fastcall virtual ~TSctTextLabel(void) { }
	
};

class DELPHICLASS TSctCheckLabel;
class PASCALIMPLEMENTATION TSctCheckLabel : public Sctctrl::TSctLabel 
{
	typedef Sctctrl::TSctLabel inherited;
	
private:
	Sctvar::TSctVar* FVariable;