// CodeGear C++Builder
// Copyright (c) 1995, 2009 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Rvstyle.pas' rev: 21.00

#ifndef RvstyleHPP
#define RvstyleHPP

#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 <Ansistrings.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 <Forms.hpp>	// Pascal unit
#include <Inifiles.hpp>	// Pascal unit
#include <Registry.hpp>	// Pascal unit
#include <Imglist.hpp>	// Pascal unit
#include <Rvclasses.hpp>	// Pascal unit
#include <Rvmapwht.hpp>	// Pascal unit
#include <Rvscroll.hpp>	// Pascal unit
#include <Rvtypes.hpp>	// Pascal unit
#include <Rvgrin.hpp>	// Pascal unit
#include <Rvwingrin.hpp>	// Pascal unit
#include <Types.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------
typedef Extended TRVLength;

namespace Rvstyle
{
//-- type declarations -------------------------------------------------------
struct TRVScreenAndDevice
{
	
public:
	int ppixScreen;
	int ppiyScreen;
	int ppixDevice;
	int ppiyDevice;
	int LeftMargin;
	int RightMargin;
};


typedef TRVScreenAndDevice *PRVScreenAndDevice;

#pragma option push -b-
enum TRVHoverEffect { rvheUnderline };
#pragma option pop

typedef Set<TRVHoverEffect, rvheUnderline, rvheUnderline>  TRVHoverEffects;

#pragma option push -b-
enum TRVSaveFormat { rvsfText, rvsfHTML, rvsfRTF, rvsfRVF };
#pragma option pop

#pragma option push -b-
enum TRVLoadFormat { rvlfText, rvlfHTML, rvlfRTF, rvlfRVF, rvlfURL, rvlfOther };
#pragma option pop

#pragma option push -b-
enum TRVRTFSaveArea { rv_rtfs_TextStyle, rv_rtfs_ParaStyle, rv_rtfs_ListStyle, rv_rtfs_CellProps, rv_rtfs_RowProps, rv_rtfs_Doc };
#pragma option pop

#pragma option push -b-
enum TRVHTMLSaveArea { rv_thms_Head, rv_thms_BodyAttribute, rv_thms_Body, rv_thms_End };
#pragma option pop

#pragma option push -b-
enum TRVReaderUnicode { rvruMixed, rvruNoUnicode, rvruOnlyUnicode };
#pragma option pop

#pragma option push -b-
enum TRVReaderStyleMode { rvrsUseSpecified, rvrsUseClosest, rvrsAddIfNeeded };
#pragma option pop

#pragma option push -b-
enum TRVFReaderStyleMode { rvf_sIgnore, rvf_sInsertMap, rvf_sInsertMerge };
#pragma option pop

#pragma option push -b-
enum TRVColorMode { rvcmColor, rvcmPrinterColor, rvcmGrayScale, rvcmBlackAndWhite, rvcmBlackOnWhite };
#pragma option pop

typedef unsigned TRVCodePage;

#pragma option push -b-
enum TRVItemBackgroundStyle { rvbsColor, rvbsStretched, rvbsTiled, rvbsCentered };
#pragma option pop

#pragma option push -b-
enum TRVSubSuperScriptType { rvsssNormal, rvsssSubscript, rvsssSuperScript };
#pragma option pop

#pragma option push -b-
enum TRVUnderlineType { rvutNormal, rvutThick, rvutDouble, rvutDotted, rvutThickDotted, rvutDashed, rvutThickDashed, rvutLongDashed, rvutThickLongDashed, rvutDashDotted, rvutThickDashDotted, rvutDashDotDotted, rvutThickDashDotDotted };
#pragma option pop

typedef void *TCheckpointData;

#pragma option push -b-
enum TRVTextDrawState { rvtsSelected, rvtsHover, rvtsItemStart, rvtsItemEnd, rvtsDrawItemStart, rvtsDrawItemEnd, rvtsControlFocused, rvtsSpecialCharacters, rvtstControlDisabled };
#pragma option pop

typedef Set<TRVTextDrawState, rvtsSelected, rvtstControlDisabled>  TRVTextDrawStates;

#pragma option push -b-
enum TRVPageBreakType { rvpbSoftPageBreak, rvpbPageBreak };
#pragma option pop

#pragma option push -b-
enum TRVBreakStyle { rvbsLine, rvbsRectangle, rvbs3d, rvbsDotted, rvbsDashed };
#pragma option pop

#pragma option push -b-
enum TRVVAlign { rvvaBaseline, rvvaMiddle, rvvaAbsTop, rvvaAbsBottom, rvvaAbsMiddle, rvvaLeft, rvvaRight };
#pragma option pop

#pragma option push -b-
enum TRVBorderStyle { rvbNone, rvbSingle, rvbDouble, rvbTriple, rvbThickInside, rvbThickOutside };
#pragma option pop

#pragma option push -b-
enum TRVSeqType { rvseqDecimal, rvseqLowerAlpha, rvseqUpperAlpha, rvseqLowerRoman, rvseqUpperRoman };
#pragma option pop

#pragma option push -b-
enum TRVListType { rvlstBullet, rvlstPicture, rvlstImageList, rvlstDecimal, rvlstLowerAlpha, rvlstUpperAlpha, rvlstLowerRoman, rvlstUpperRoman, rvlstImageListCounter, rvlstUnicodeBullet };
#pragma option pop

#pragma option push -b-
enum TRVMarkerAlignment { rvmaLeft, rvmaRight, rvmaCenter };
#pragma option pop

#pragma option push -b-
enum TRVListLevelOption { rvloContinuous, rvloLevelReset, rvloLegalStyleNumbering };
#pragma option pop

typedef Set<TRVListLevelOption, rvloContinuous, rvloLegalStyleNumbering>  TRVListLevelOptions;

typedef System::UnicodeString TRVMarkerFormatString;

typedef Rvtypes::TRVUnicodeString TRVMarkerFormatStringW;

#pragma option push -b-
enum TRVFOption { rvfoSavePicturesBody, rvfoSaveControlsBody, rvfoIgnoreUnknownPicFmt, rvfoIgnoreUnknownCtrls, rvfoIgnoreUnknownCtrlProperties, rvfoConvUnknownStylesToZero, rvfoConvLargeImageIdxToZero, rvfoSaveBinary, rvfoUseStyleNames, rvfoSaveBack, rvfoLoadBack, rvfoSaveTextStyles, rvfoSaveParaStyles, rvfoSaveLayout, rvfoLoadLayout, rvfoSaveDocProperties, rvfoLoadDocProperties, rvfoCanChangeUnits };
#pragma option pop

typedef Set<TRVFOption, rvfoSavePicturesBody, rvfoCanChangeUnits>  TRVFOptions;

#pragma option push -b-
enum TRVLongOperation { rvloLoading, rvloConverting };
#pragma option pop

#pragma option push -b-
enum TRVProgressStage { rvpstgStarting, rvpstgRunning, rvpstgEnding };
#pragma option pop

#pragma option push -b-
enum TRVFWarning { rvfwUnknownPicFmt, rvfwUnknownCtrls, rvfwConvUnknownStyles, rvfwConvLargeImageIdx, rvfwConvToUnicode, rvfwConvFromUnicode, rvfwInvalidPicture, rvfwUnknownStyleProperties, rvfwUnknownCtrlProperties, rvfwConvUnits };
#pragma option pop

typedef Set<TRVFWarning, rvfwUnknownPicFmt, rvfwConvUnits>  TRVFWarnings;

#pragma option push -b-
enum TRVControlAction { rvcaAfterRVFLoad, rvcaDestroy, rvcaMoveToUndoList, rvcaMoveFromUndoList, rvcaDestroyInUndoList, rvcaBeforeRVFSave, rvcaAfterRVFSave };
#pragma option pop

#pragma option push -b-
enum TRVItemAction { rviaInserting, rviaInserted, rviaTextModifying, rviaDestroying, rviaMovingToUndoList };
#pragma option pop

#pragma option push -b-
enum TRVProtectOption { rvprStyleProtect, rvprStyleSplitProtect, rvprModifyProtect, rvprDeleteProtect, rvprConcateProtect, rvprRVFInsertProtect, rvprDoNotAutoSwitch, rvprParaStartProtect, rvprSticking, rvprSticking2, rvprSticking3, rvprStickToTop, rvprStickToBottom };
#pragma option pop

typedef Set<TRVProtectOption, rvprStyleProtect, rvprStickToBottom>  TRVProtectOptions;

#pragma option push -b-
enum TRVParaOption { rvpaoNoWrap, rvpaoReadOnly, rvpaoStyleProtect, rvpaoDoNotWantReturns, rvpaoKeepLinesTogether, rvpaoKeepWithNext, rvpaoWidowOrphanControl };
#pragma option pop

typedef Set<TRVParaOption, rvpaoNoWrap, rvpaoWidowOrphanControl>  TRVParaOptions;

#pragma option push -b-
enum TRVTextOption { rvteoHTMLCode, rvteoRTFCode, rvteoHidden };
#pragma option pop

typedef Set<TRVTextOption, rvteoHTMLCode, rvteoHidden>  TRVTextOptions;

#pragma option push -b-
enum TRVSaveOption { rvsoOverrideImages, rvsoFirstOnly, rvsoMiddleOnly, rvsoLastOnly, rvsoDefault0Style, rvsoNoHypertextImageBorders, rvsoImageSizes, rvsoForceNonTextCSS, rvsoUseCheckpointsNames, rvsoMarkersAsText, rvsoInlineCSS, rvsoNoDefCSSStyle, rvsoUseItemImageFileNames, rvsoXHTML, rvsoUTF8 };
#pragma option pop

typedef Set<TRVSaveOption, rvsoOverrideImages, rvsoUTF8>  TRVSaveOptions;

#pragma option push -b-
enum TRVRTFOption { rvrtfSaveStyleSheet, rvrtfDuplicateUnicode, rvrtfSaveEMFAsWMF, rvrtfSaveJpegAsJpeg, rvrtfSaveBitmapDefault, rvrtfSaveEMFDefault, rvrtfSavePicturesBinary, rvrtfPNGInsteadOfBitmap, rvrtfSaveDocParameters, rvrtfSaveHeaderFooter };
#pragma option pop

typedef Set<TRVRTFOption, rvrtfSaveStyleSheet, rvrtfSaveHeaderFooter>  TRVRTFOptions;

#pragma option push -b-
enum TRVFontStyle { rvfsOverline, rvfsAllCaps };
#pragma option pop

typedef Set<TRVFontStyle, rvfsOverline, rvfsAllCaps>  TRVFontStyles;

#pragma option push -b-
enum TRVAlignment { rvaLeft, rvaRight, rvaCenter, rvaJustify };
#pragma option pop

#pragma option push -b-
enum TRVUnits { rvuInches, rvuCentimeters, rvuMillimeters, rvuPicas, rvuPixels, rvuPoints };
#pragma option pop

typedef System::Extended TRVLength;

#pragma option push -b-
enum TRVLineWrapMode { rvWrapAnywhere, rvWrapSimple, rvWrapNormal };
#pragma option pop

struct TRVExtraFontInfo
{
	
public:
	int ScriptHeight;
};


typedef TRVExtraFontInfo *PRVExtraFontInfo;

typedef Inifiles::TCustomIniFile TRVIniFile;

#pragma option push -b-
enum TRVSaveCSSOption { rvcssOnlyDifference, rvcssIgnoreLeftAlignment, rvcssNoDefCSSStyle, rvcssUTF8, rvcssDefault0Style };
#pragma option pop

typedef Set<TRVSaveCSSOption, rvcssOnlyDifference, rvcssDefault0Style>  TRVSaveCSSOptions;

#pragma option push -b-
enum TRVFontInfoProperty { rvfiFontName, rvfiSize, rvfiCharset, rvfiUnicode, rvfiBold, rvfiItalic, rvfiUnderline, rvfiStrikeout, rvfiOverline, rvfiAllCaps, rvfiSubSuperScriptType, rvfiVShift, rvfiColor, rvfiBackColor, rvfiJump, rvfiHoverBackColor, rvfiHoverColor, rvfiHoverUnderline, rvfiJumpCursor, rvfiNextStyleNo, rvfiProtection, rvfiCharScale, rvfiBaseStyleNo, rvfiBiDiMode, rvfiCharSpacing, rvfiHTMLCode, rvfiRTFCode, rvfiHidden, rvfiUnderlineType, rvfiUnderlineColor, rvfiHoverUnderlineColor, rvfiCustom };
#pragma option pop

#pragma option push -b-
enum TRVParaInfoProperty { rvpiFirstIndent, rvpiLeftIndent, rvpiRightIndent, rvpiSpaceBefore, rvpiSpaceAfter, rvpiAlignment, rvpiNextParaNo, rvpiDefStyleNo, rvpiLineSpacing, rvpiLineSpacingType, rvpiBackground_Color, rvpiBackground_BO_Left, rvpiBackground_BO_Top, rvpiBackground_BO_Right, rvpiBackground_BO_Bottom, rvpiBorder_Color, rvpiBorder_Style, rvpiBorder_Width, rvpiBorder_InternalWidth, rvpiBorder_BO_Left, rvpiBorder_BO_Top, rvpiBorder_BO_Right, rvpiBorder_BO_Bottom, rvpiBorder_Vis_Left, rvpiBorder_Vis_Top, rvpiBorder_Vis_Right, rvpiBorder_Vis_Bottom, rvpiNoWrap, rvpiReadOnly, rvpiStyleProtect, rvpiDoNotWantReturns, rvpiKeepLinesTogether, rvpiKeepWithNext, rvpiTabs, rvpiBiDiMode, rvpiOutlineLevel, rvpiCustom };
#pragma option pop

typedef TRVParaInfoProperty TRVParaInfoProperty1;

typedef TRVParaInfoProperty TRVParaInfoProperty2;

typedef TRVFontInfoProperty TRVFontInfoProperty1;

typedef TRVFontInfoProperty TRVFontInfoProperty2;

typedef Set<TRVFontInfoProperty, rvfiFontName, rvfiCustom>  TRVFontInfoProperties;

typedef Set<TRVParaInfoProperty, rvpiFirstIndent, rvpiCustom>  TRVParaInfoProperties;

typedef Set<TRVParaInfoProperty1, rvpiFirstIndent, rvpiBorder_Vis_Bottom>  TRVParaInfoProperties1;

typedef Set<TRVParaInfoProperty2, rvpiNoWrap, rvpiOutlineLevel>  TRVParaInfoProperties2;

typedef Set<TRVFontInfoProperty1, rvfiFontName, rvfiJumpCursor>  TRVFontInfoProperties1;

typedef Set<TRVFontInfoProperty2, rvfiNextStyleNo, rvfiHoverUnderlineColor>  TRVFontInfoProperties2;

#pragma option push -b-
enum TRVLineSpacingType { rvlsPercent, rvlsSpaceBetween, rvlsLineHeightAtLeast, rvlsLineHeightExact };
#pragma option pop

typedef int TRVLineSpacingValue;

#pragma option push -b-
enum TRVStyleMergeMode { rvs_merge_SmartMerge, rvs_merge_Map, rvs_merge_Append };
#pragma option pop

#pragma option push -b-
enum TRVSelectionMode { rvsmChar, rvsmWord, rvsmParagraph };
#pragma option pop

#pragma option push -b-
enum TRVSelectionStyle { rvssItems, rvssLines };
#pragma option pop

#pragma option push -b-
enum TRVTabAlign { rvtaLeft, rvtaRight, rvtaCenter };
#pragma option pop

typedef int TRVStyleTemplateId;

typedef System::UnicodeString TRVStyleTemplateName;

#pragma option push -b-
enum TRVSpecialCharacter { rvscSpace, rvscNBSP, rvscTab, rvscParagraph, rvscSoftHyphen, rvscParagraphAttrs, rvcFloatingLines };
#pragma option pop

typedef Set<TRVSpecialCharacter, rvscSpace, rvcFloatingLines>  TRVSpecialCharacters;

#pragma option push -b-
enum TRVParagraphMarks { rvpmStandard, rvpmArrows };
#pragma option pop

#pragma option push -b-
enum TRVFieldHighlightType { rvfhNever, rvfhCurrent, rvfhAlways };
#pragma option pop

#pragma option push -b-
enum TRVStyleUnits { rvstuPixels, rvstuTwips };
#pragma option pop

typedef TRVStyleUnits *PRVStyleUnits;

typedef int TRVStyleLength;

class DELPHICLASS TRVStyle;
typedef void __fastcall (__closure *TRVDrawTextBackEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int StyleNo, int Left, int Top, int Width, int Height, TRVTextDrawStates DrawState, bool &DoDefault);

typedef void __fastcall (__closure *TRVApplyStyleEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int StyleNo, bool &DoDefault);

typedef void __fastcall (__closure *TRVAfterApplyStyleEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int StyleNo);

typedef void __fastcall (__closure *TRVApplyStyleColorEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int StyleNo, TRVTextDrawStates DrawState, bool &DoDefault);

typedef void __fastcall (__closure *TRVDrawStyleTextEvent)(TRVStyle* Sender, const Rvtypes::TRVRawByteString s, Graphics::TCanvas* Canvas, int StyleNo, int SpaceBefore, int Left, int Top, int Width, int Height, TRVTextDrawStates DrawState, bool &DoDefault);

typedef void __fastcall (__closure *TRVStyleHoverSensitiveEvent)(TRVStyle* Sender, int StyleNo, bool &Sensitive);

typedef void __fastcall (__closure *TRVDrawCheckpointEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int X, int Y, int ItemNo, int XShift, bool RaiseEvent, Controls::TControl* Control, bool &DoDefault);

typedef void __fastcall (__closure *TRVDrawPageBreakEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int Y, int XShift, TRVPageBreakType PageBreakType, Controls::TControl* Control, bool &DoDefault);

typedef void __fastcall (__closure *TRVDrawParaRectEvent)(TRVStyle* Sender, Graphics::TCanvas* Canvas, int ParaNo, const Types::TRect &ARect, bool &DoDefault);

typedef void __fastcall (__closure *TRVGetGraphicInterfaceEvent)(TRVStyle* Sender, Rvgrin::TRVGraphicInterface* &GraphicInterface);

class DELPHICLASS TCustomRVInfo;
class PASCALIMPLEMENTATION TCustomRVInfo : public Classes::TCollectionItem
{
	typedef Classes::TCollectionItem inherited;
	
private:
	int FBaseStyleNo;
	System::UnicodeString FName;
	bool FStandard;
	TRVStyleTemplateId FStyleTemplateId;
	
protected:
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	DYNAMIC bool __fastcall IsSimpleEqualEx(TCustomRVInfo* Value, Rvclasses::TRVIntegerList* Mapping);
	DYNAMIC int __fastcall SimilarityValue(TCustomRVInfo* Value);
	
public:
	__fastcall virtual TCustomRVInfo(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs, const System::UnicodeString DefName);
	DYNAMIC void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits) = 0 ;
	virtual TRVStyle* __fastcall GetRVStyle(void);
	
__published:
	__property int BaseStyleNo = {read=FBaseStyleNo, write=FBaseStyleNo, default=-1};
	__property System::UnicodeString StyleName = {read=FName, write=FName};
	__property bool Standard = {read=FStandard, write=FStandard, default=1};
	__property TRVStyleTemplateId StyleTemplateId = {read=FStyleTemplateId, write=FStyleTemplateId, default=-1};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TCustomRVInfo(void) { }
	
};


class DELPHICLASS TCustomRVFontInfo;
class PASCALIMPLEMENTATION TCustomRVFontInfo : public TCustomRVInfo
{
	typedef TCustomRVInfo inherited;
	
private:
	Rvscroll::TRVBiDiMode FBiDiMode;
	bool FJump;
	Controls::TCursor FJumpCursor;
	Graphics::TFontName FFontName;
	int FSize;
	Graphics::TColor FColor;
	Graphics::TColor FBackColor;
	Graphics::TColor FHoverColor;
	Graphics::TColor FHoverBackColor;
	Graphics::TColor FUnderlineColor;
	Graphics::TColor FHoverUnderlineColor;
	TRVUnderlineType FUnderlineType;
	TRVHoverEffects FHoverEffects;
	Graphics::TFontStyles FStyle;
	TRVFontStyles FStyleEx;
	int FVShift;
	Graphics::TFontCharset FCharset;
	TRVProtectOptions FProtection;
	TRVTextOptions FOptions;
	int FCharScale;
	TRVStyleLength FCharSpacing;
	TRVSubSuperScriptType FSubSuperScriptType;
	void __fastcall SingleSymbolsReader(Classes::TReader* reader);
	
protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	DYNAMIC int __fastcall SimilarityValue(TCustomRVInfo* Value);
	int __fastcall GetScriptHeight(Graphics::TCanvas* Canvas, Rvgrin::TRVGraphicInterface* GraphicInterface);
	
public:
	__fastcall virtual TCustomRVFontInfo(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	void __fastcall AssignSelectedProperties(TCustomRVFontInfo* Source, TRVFontInfoProperties Props);
	void __fastcall AssignToLogFont(tagLOGFONTW &LogFont, Graphics::TCanvas* Canvas, bool CanUseCustomPPI, bool ExcludeUnderline, bool ToFormatCanvas);
	void __fastcall Apply(Graphics::TCanvas* Canvas, Rvscroll::TRVBiDiMode DefBiDiMode, bool CanUseCustomPPI, PRVExtraFontInfo ExtraFontInfo, bool IgnoreSubSuperScript, bool ToFormatCanvas, Rvgrin::TRVGraphicInterface* GraphicInterface);
	void __fastcall ApplyBiDiMode(Graphics::TCanvas* Canvas, Rvscroll::TRVBiDiMode DefBiDiMode, bool ToFormatCanvas, Rvgrin::TRVGraphicInterface* GraphicInterface);
	void __fastcall ApplyColor(Graphics::TCanvas* Canvas, TRVStyle* RVStyle, TRVTextDrawStates DrawState, bool Printing, TRVColorMode ColorMode);
	DYNAMIC bool __fastcall IsEqual(TCustomRVFontInfo* Value, TRVFontInfoProperties IgnoreList);
	HIDESBASEDYNAMIC void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs, bool JumpByDefault, Controls::TCursor DefJumpCursor);
	void __fastcall SaveCSSToStream(Classes::TStream* Stream, TCustomRVFontInfo* BaseStyle, bool Multiline, bool UTF8);
	void __fastcall SaveRTFToStream(Classes::TStream* Stream, int StyleNo, double TwipsPerPixel, Rvclasses::TRVIntegerList* StyleToFont, Rvclasses::TRVIntegerList* ColorTable);
	DYNAMIC void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits);
	
__published:
	__property Graphics::TFontCharset Charset = {read=FCharset, write=FCharset, default=1};
	__property Graphics::TFontName FontName = {read=FFontName, write=FFontName};
	__property int Size = {read=FSize, write=FSize, default=10};
	__property Graphics::TFontStyles Style = {read=FStyle, write=FStyle, default=0};
	__property int VShift = {read=FVShift, write=FVShift, default=0};
	__property Graphics::TColor Color = {read=FColor, write=FColor, default=-16777208};
	__property Graphics::TColor BackColor = {read=FBackColor, write=FBackColor, default=536870911};
	__property Graphics::TColor HoverBackColor = {read=FHoverBackColor, write=FHoverBackColor, default=536870911};
	__property Graphics::TColor HoverColor = {read=FHoverColor, write=FHoverColor, default=536870911};
	__property TRVHoverEffects HoverEffects = {read=FHoverEffects, write=FHoverEffects, default=0};
	__property TRVFontStyles StyleEx = {read=FStyleEx, write=FStyleEx, default=0};
	__property bool Jump = {read=FJump, write=FJump, default=0};
	__property Controls::TCursor JumpCursor = {read=FJumpCursor, write=FJumpCursor, default=101};
	__property int CharScale = {read=FCharScale, write=FCharScale, default=100};
	__property TRVStyleLength CharSpacing = {read=FCharSpacing, write=FCharSpacing, default=0};
	__property Rvscroll::TRVBiDiMode BiDiMode = {read=FBiDiMode, write=FBiDiMode, default=0};
	__property TRVSubSuperScriptType SubSuperScriptType = {read=FSubSuperScriptType, write=FSubSuperScriptType, default=0};
	__property TRVProtectOptions Protection = {read=FProtection, write=FProtection, default=0};
	__property TRVTextOptions Options = {read=FOptions, write=FOptions, default=0};
	__property TRVUnderlineType UnderlineType = {read=FUnderlineType, write=FUnderlineType, default=0};
	__property Graphics::TColor UnderlineColor = {read=FUnderlineColor, write=FUnderlineColor, default=536870911};
	__property Graphics::TColor HoverUnderlineColor = {read=FHoverUnderlineColor, write=FHoverUnderlineColor, default=536870911};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TCustomRVFontInfo(void) { }
	
};


class DELPHICLASS TFontInfo;
class PASCALIMPLEMENTATION TFontInfo : public TCustomRVFontInfo
{
	typedef TCustomRVFontInfo inherited;
	
private:
	bool FUnicode;
	int FNextStyleNo;
	TRVFontInfoProperties1 FModifiedProperties1;
	TRVFontInfoProperties2 FModifiedProperties2;
	
protected:
	DYNAMIC bool __fastcall IsSimpleEqualEx(TCustomRVInfo* Value, Rvclasses::TRVIntegerList* Mapping);
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	void __fastcall ExcludeUnmodifiedProperties(TCustomRVFontInfo* Source, TRVFontInfoProperties PossibleProps);
	
public:
	__fastcall virtual TFontInfo(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	DYNAMIC bool __fastcall IsEqual(TCustomRVFontInfo* Value, TRVFontInfoProperties IgnoreList);
	void __fastcall Draw(const Rvtypes::TRVRawByteString s, Graphics::TCanvas* Canvas, int ThisStyleNo, int SpaceAtLeft, int Left, int Top, int Width, int Height, int BaseLine, TRVStyle* RVStyle, TRVTextDrawStates DrawState, bool Printing, bool PreviewCorrection, TRVColorMode ColorMode, Rvscroll::TRVBiDiMode DefBiDiMode, Graphics::TCanvas* RefCanvas, Rvgrin::TRVGraphicInterface* GraphicInterface);
	void __fastcall DrawVertical(const Rvtypes::TRVRawByteString s, Graphics::TCanvas* Canvas, int ThisStyleNo, int SpaceBefore, int Left, int Top, int Width, int Height, TRVStyle* RVStyle, TRVTextDrawStates DrawState);
	DYNAMIC void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	DYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs, bool JumpByDefault, Controls::TCursor DefJumpCursor);
	
__published:
	__property int NextStyleNo = {read=FNextStyleNo, write=FNextStyleNo, default=-1};
	__property bool Unicode = {read=FUnicode, write=FUnicode, nodefault};
	__property TRVFontInfoProperties1 ModifiedProperties1 = {read=FModifiedProperties1, write=FModifiedProperties1, default=0};
	__property TRVFontInfoProperties2 ModifiedProperties2 = {read=FModifiedProperties2, write=FModifiedProperties2, default=0};
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TFontInfo(void) { }
	
};


class DELPHICLASS TErrFontInfo;
class PASCALIMPLEMENTATION TErrFontInfo : public TFontInfo
{
	typedef TFontInfo inherited;
	
private:
	TRVStyle* FRVStyle;
	
public:
	__fastcall TErrFontInfo(TRVStyle* RVStyle);
	virtual TRVStyle* __fastcall GetRVStyle(void);
public:
	/* TFontInfo.Create */ inline __fastcall virtual TErrFontInfo(Classes::TCollection* Collection) : TFontInfo(Collection) { }
	
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TErrFontInfo(void) { }
	
};


class DELPHICLASS TCustomRVInfos;
class PASCALIMPLEMENTATION TCustomRVInfos : public Classes::TCollection
{
	typedef Classes::TCollection inherited;
	
protected:
	Classes::TPersistent* FOwner;
	
public:
	__fastcall TCustomRVInfos(Classes::TCollectionItemClass ItemClass, Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	void __fastcall MergeWith(TCustomRVInfos* Styles, TRVStyleMergeMode Mode, Rvclasses::TRVIntegerList* Mapping, Rvclasses::TRVIntegerList* TextStyleMapping, Classes::TPersistent* RVData = (Classes::TPersistent*)(0x0));
	void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits);
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TCustomRVInfos(void) { }
	
};


class DELPHICLASS TFontInfos;
class PASCALIMPLEMENTATION TFontInfos : public TCustomRVInfos
{
	typedef TCustomRVInfos inherited;
	
public:
	TFontInfo* operator[](int Index) { return Items[Index]; }
	
private:
	TFontInfo* FInvalidItem;
	HIDESBASE TFontInfo* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TFontInfo* Value);
	TFontInfo* __fastcall GetInvalidItem(void);
	void __fastcall SetInvalidItem(const TFontInfo* Value);
	
public:
	int PixelsPerInch;
	__fastcall virtual ~TFontInfos(void);
	int __fastcall FindStyleWithCharset(int BaseStyle, Graphics::TFontCharset Charset);
	int __fastcall FindStyleWithFontStyle(int BaseStyle, Graphics::TFontStyles Value, Graphics::TFontStyles Mask);
	int __fastcall FindStyleWithFontSize(int BaseStyle, int Size);
	int __fastcall FindStyleWithColor(int BaseStyle, Graphics::TColor Color, Graphics::TColor BackColor);
	int __fastcall FindStyleWithFontName(int BaseStyle, const Graphics::TFontName FontName);
	int __fastcall FindSuchStyle(int BaseStyle, TFontInfo* Style, TRVFontInfoProperties Mask);
	int __fastcall FindStyleWithFont(int BaseStyle, Graphics::TFont* Font);
	HIDESBASE TFontInfo* __fastcall Add(void);
	TFontInfo* __fastcall AddFont(Graphics::TFontName Name, int Size, Graphics::TColor Color, Graphics::TColor BackColor, Graphics::TFontStyles Style);
	TFontInfo* __fastcall AddFontEx(Graphics::TFontName Name, int Size, Graphics::TColor Color, Graphics::TColor BackColor, Graphics::TFontStyles Style, Graphics::TFontCharset Charset);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, Controls::TCursor DefJumpCursor);
	__property TFontInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	__property TFontInfo* InvalidItem = {read=GetInvalidItem, write=SetInvalidItem};
public:
	/* TCustomRVInfos.Create */ inline __fastcall TFontInfos(Classes::TCollectionItemClass ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
	
};


class DELPHICLASS TRVRect;
class PASCALIMPLEMENTATION TRVRect : public Classes::TPersistent
{
	typedef Classes::TPersistent inherited;
	
private:
	Classes::TPersistent* FOwner;
	TRVStyleLength FTop;
	TRVStyleLength FLeft;
	TRVStyleLength FRight;
	TRVStyleLength FBottom;
	bool __fastcall IsEqualEx(TRVRect* Value, bool IgnL, bool IgnT, bool IgnR, bool IgnB);
	int __fastcall SimilarityValue(TRVRect* Value, TRVStyleLength Weight, int Wht);
	
public:
	__fastcall TRVRect(Classes::TPersistent* AOwner);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall AssignValidProperties(TRVRect* Source, bool ValL, bool ValT, bool ValR, bool ValB);
	void __fastcall SetAll(TRVStyleLength Value);
	void __fastcall InflateRect(Types::TRect &Rect, TRVStyle* RVStyle);
	void __fastcall InflateRectSaD(Types::TRect &Rect, TRVStyle* RVStyle, const TRVScreenAndDevice &sad);
	void __fastcall AssignToRect(Types::TRect &Rect);
	void __fastcall AssignToRectIfGreater(Types::TRect &Rect);
	bool __fastcall IsEqual(TRVRect* Value);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall ConvertToDifferentUnits(TRVStyle* RVStyle, TRVStyleUnits NewUnits);
	__property Classes::TPersistent* Owner = {read=FOwner};
	
__published:
	__property TRVStyleLength Left = {read=FLeft, write=FLeft, default=0};
	__property TRVStyleLength Right = {read=FRight, write=FRight, default=0};
	__property TRVStyleLength Top = {read=FTop, write=FTop, default=0};
	__property TRVStyleLength Bottom = {read=FBottom, write=FBottom, default=0};
public:
	/* TPersistent.Destroy */ inline __fastcall virtual ~TRVRect(void) { }
	
public:
	/* TObject.Create */ inline __fastcall TRVRect(void) : Classes::TPersistent() { }
	
};


class DELPHICLASS TRVBooleanRect;
class PASCALIMPLEMENTATION TRVBooleanRect : public Classes::TPersistent
{
	typedef Classes::TPersistent inherited;
	
private:
	bool FTop;
	bool FLeft;
	bool FRight;
	bool FBottom;
	bool __fastcall IsEqualEx(TRVBooleanRect* Value, bool IgnL, bool IgnT, bool IgnR, bool IgnB);
	
public:
	__fastcall TRVBooleanRect(bool DefValue);
	void __fastcall SetAll(bool Value);
	void __fastcall SetValues(bool ALeft, bool ATop, bool ARight, bool ABottom);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall AssignValidProperties(TRVBooleanRect* Source, bool ValL, bool ValT, bool ValR, bool ValB);
	bool __fastcall IsEqual(TRVBooleanRect* Value);
	bool __fastcall IsEqual2(bool ALeft, bool ATop, bool ARight, bool ABottom);
	bool __fastcall IsAllEqual(bool Value);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	
__published:
	__property bool Left = {read=FLeft, write=FLeft, default=1};
	__property bool Right = {read=FRight, write=FRight, default=1};
	__property bool Top = {read=FTop, write=FTop, default=1};
	__property bool Bottom = {read=FBottom, write=FBottom, default=1};
public:
	/* TPersistent.Destroy */ inline __fastcall virtual ~TRVBooleanRect(void) { }
	
};


class DELPHICLASS TRVBorder;
class PASCALIMPLEMENTATION TRVBorder : public Classes::TPersistent
{
	typedef Classes::TPersistent inherited;
	
private:
	Graphics::TColor FColor;
	TRVBorderStyle FStyle;
	TRVStyleLength FWidthX;
	TRVStyleLength FInternalWidthX;
	TRVBooleanRect* FVisibleBorders;
	TRVRect* FBorderOffsets;
	Classes::TPersistent* FOwner;
	void __fastcall SetBorderOffsets(const TRVRect* Value);
	void __fastcall SetVisibleBorders(const TRVBooleanRect* Value);
	int __fastcall SimilarityValue(TRVBorder* Value, int Wht);
	
protected:
	void __fastcall DoDraw(const Types::TRect &ARect, Graphics::TCanvas* Canvas, int WidthLR, int WidthTB, int InternalWidthLR, int InternalWidthTB, TRVColorMode ColorMode, Rvgrin::TRVGraphicInterface* GraphicInterface);
	
public:
	__fastcall TRVBorder(Classes::TPersistent* AOwner);
	__fastcall virtual ~TRVBorder(void);
	void __fastcall Draw(const Types::TRect &Rect, Graphics::TCanvas* Canvas, TRVStyle* RVStyle, Rvgrin::TRVGraphicInterface* GraphicInterface);
	void __fastcall DrawSaD(const Types::TRect &Rect, Graphics::TCanvas* Canvas, TRVStyle* RVStyle, const TRVScreenAndDevice &sad, TRVColorMode ColorMode, Rvgrin::TRVGraphicInterface* GraphicInterface);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	bool __fastcall IsEqual(TRVBorder* Value);
	bool __fastcall IsEqual_Para(TRVBorder* Value, const TRVParaInfoProperties &IgnoreList);
	void __fastcall AssignValidProperties(TRVBorder* Source, TRVParaInfoProperties1 ValidProperties);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	TRVStyleLength __fastcall GetTotalWidth(void);
	void __fastcall ConvertToDifferentUnits(TRVStyle* RVStyle, TRVStyleUnits NewUnits);
	__property Classes::TPersistent* Owner = {read=FOwner};
	
__published:
	__property TRVStyleLength Width = {read=FWidthX, write=FWidthX, default=1};
	__property TRVStyleLength InternalWidth = {read=FInternalWidthX, write=FInternalWidthX, default=1};
	__property Graphics::TColor Color = {read=FColor, write=FColor, default=-16777208};
	__property TRVBorderStyle Style = {read=FStyle, write=FStyle, default=0};
	__property TRVBooleanRect* VisibleBorders = {read=FVisibleBorders, write=SetVisibleBorders};
	__property TRVRect* BorderOffsets = {read=FBorderOffsets, write=SetBorderOffsets};
};


class DELPHICLASS TRVBackgroundRect;
class PASCALIMPLEMENTATION TRVBackgroundRect : public Classes::TPersistent
{
	typedef Classes::TPersistent inherited;
	
private:
	TRVRect* FBorderOffsets;
	Graphics::TColor FColor;
	Classes::TPersistent* FOwner;
	void __fastcall SetBorderOffsets(const TRVRect* Value);
	int __fastcall SimilarityValue(TRVBackgroundRect* Value, int Wht);
	
public:
	__fastcall TRVBackgroundRect(Classes::TPersistent* AOwner);
	__fastcall virtual ~TRVBackgroundRect(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall PrepareDraw(Types::TRect &Rect, TRVStyle* RVStyle);
	void __fastcall PrepareDrawSaD(Types::TRect &Rect, TRVStyle* RVStyle, const TRVScreenAndDevice &sad);
	void __fastcall Draw(const Types::TRect &Rect, Graphics::TCanvas* Canvas, bool Printing, TRVColorMode ColorMode, Rvgrin::TRVGraphicInterface* GraphicInterface);
	bool __fastcall IsEqual(TRVBackgroundRect* Value);
	bool __fastcall IsEqual_Para(TRVBackgroundRect* Value, const TRVParaInfoProperties &IgnoreList);
	void __fastcall AssignValidProperties(TRVBackgroundRect* Source, TRVParaInfoProperties1 ValidProperties);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	__property Classes::TPersistent* Owner = {read=FOwner};
	
__published:
	__property Graphics::TColor Color = {read=FColor, write=FColor, default=536870911};
	__property TRVRect* BorderOffsets = {read=FBorderOffsets, write=SetBorderOffsets};
};


class DELPHICLASS TRVTabInfo;
class PASCALIMPLEMENTATION TRVTabInfo : public Classes::TCollectionItem
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TRVStyleLength FPosition;
	System::UnicodeString FLeader;
	TRVTabAlign FAlign;
	bool __fastcall StoreLeader(void);
	void __fastcall SetPosition(const TRVStyleLength Value);
	
protected:
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	
public:
	bool __fastcall IsEqual(TRVTabInfo* Value);
	int __fastcall SimilarityValue(TRVTabInfo* Value, int Wht);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	
__published:
	__property TRVTabAlign Align = {read=FAlign, write=FAlign, default=0};
	__property TRVStyleLength Position = {read=FPosition, write=SetPosition, nodefault};
	__property System::UnicodeString Leader = {read=FLeader, write=FLeader, stored=StoreLeader};
public:
	/* TCollectionItem.Create */ inline __fastcall virtual TRVTabInfo(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRVTabInfo(void) { }
	
};


class DELPHICLASS TRVTabInfos;
class PASCALIMPLEMENTATION TRVTabInfos : public Classes::TCollection
{
	typedef Classes::TCollection inherited;
	
public:
	TRVTabInfo* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TRVTabInfo* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TRVTabInfo* Value);
	
public:
	__fastcall TRVTabInfos(Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	HIDESBASE TRVTabInfo* __fastcall Add(void);
	void __fastcall SortTabs(void);
	bool __fastcall IsEqual(TRVTabInfos* Value);
	int __fastcall Find(int Position);
	int __fastcall SimilarityValue(TRVTabInfos* Value, int Wht);
	void __fastcall Intersect(TRVTabInfos* Value);
	void __fastcall AddFrom(TRVTabInfos* Source);
	void __fastcall DeleteList(Rvclasses::TRVIntegerList* Positions);
	void __fastcall ConvertToDifferentUnits(TRVStyle* RVStyle, TRVStyleUnits NewUnits);
	__property TRVTabInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TRVTabInfos(void) { }
	
};


class DELPHICLASS TCustomRVParaInfo;
class DELPHICLASS TParaInfo;
class PASCALIMPLEMENTATION TCustomRVParaInfo : public TCustomRVInfo
{
	typedef TCustomRVInfo inherited;
	
private:
	TRVStyleLength FFirstIndent;
	TRVStyleLength FLeftIndent;
	TRVStyleLength FRightIndent;
	TRVStyleLength FSpaceBefore;
	TRVStyleLength FSpaceAfter;
	TRVLineSpacingValue FLineSpacing;
	TRVLineSpacingType FLineSpacingType;
	TRVAlignment FAlignment;
	TRVBorder* FBorder;
	TRVBackgroundRect* FBackground;
	TRVParaOptions FOptions;
	Rvscroll::TRVBiDiMode FBiDiMode;
	int FOutlineLevel;
	TRVTabInfos* FTabs;
	void __fastcall SetBorder(const TRVBorder* Value);
	void __fastcall SetBackground(const TRVBackgroundRect* Value);
	bool __fastcall ExtraLineSpacing(void);
	void __fastcall SetTabs(const TRVTabInfos* Value);
	void __fastcall SetSpaceAfter(const TRVStyleLength Value);
	void __fastcall SetSpaceBefore(const TRVStyleLength Value);
	
protected:
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	DYNAMIC int __fastcall SimilarityValue(TCustomRVInfo* Value);
	
public:
	__fastcall virtual TCustomRVParaInfo(Classes::TCollection* Collection);
	__fastcall virtual ~TCustomRVParaInfo(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall AssignSelectedProperties(TCustomRVParaInfo* Source, const TRVParaInfoProperties &Props);
	HIDESBASEDYNAMIC void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	DYNAMIC bool __fastcall IsEqual(TCustomRVParaInfo* Value, const TRVParaInfoProperties &IgnoreList);
	void __fastcall SaveCSSToStream(Classes::TStream* Stream, TParaInfo* BaseStyle, bool Multiline, bool IgnoreLeftAlignment, bool IgnoreLeftIndents);
	DYNAMIC void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits);
	
__published:
	__property TRVStyleLength FirstIndent = {read=FFirstIndent, write=FFirstIndent, default=0};
	__property TRVStyleLength LeftIndent = {read=FLeftIndent, write=FLeftIndent, default=0};
	__property TRVStyleLength RightIndent = {read=FRightIndent, write=FRightIndent, default=0};
	__property TRVStyleLength SpaceBefore = {read=FSpaceBefore, write=SetSpaceBefore, default=0};
	__property TRVStyleLength SpaceAfter = {read=FSpaceAfter, write=SetSpaceAfter, default=0};
	__property TRVAlignment Alignment = {read=FAlignment, write=FAlignment, default=0};
	__property TRVBorder* Border = {read=FBorder, write=SetBorder};
	__property TRVBackgroundRect* Background = {read=FBackground, write=SetBackground};
	__property TRVLineSpacingValue LineSpacing = {read=FLineSpacing, write=FLineSpacing, default=100};
	__property TRVLineSpacingType LineSpacingType = {read=FLineSpacingType, write=FLineSpacingType, default=0};
	__property TRVParaOptions Options = {read=FOptions, write=FOptions, default=0};
	__property Rvscroll::TRVBiDiMode BiDiMode = {read=FBiDiMode, write=FBiDiMode, default=0};
	__property int OutlineLevel = {read=FOutlineLevel, write=FOutlineLevel, default=0};
	__property TRVTabInfos* Tabs = {read=FTabs, write=SetTabs};
};


class PASCALIMPLEMENTATION TParaInfo : public TCustomRVParaInfo
{
	typedef TCustomRVParaInfo inherited;
	
private:
	int FNextParaNo;
	int FDefStyleNo;
	TRVParaInfoProperties1 FModifiedProperties1;
	TRVParaInfoProperties2 FModifiedProperties2;
	
protected:
	DYNAMIC bool __fastcall IsSimpleEqualEx(TCustomRVInfo* Value, Rvclasses::TRVIntegerList* Mapping);
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	void __fastcall ExcludeUnmodifiedProperties(TCustomRVParaInfo* Source, const TRVParaInfoProperties &PossibleProps);
	
public:
	__fastcall virtual TParaInfo(Classes::TCollection* Collection);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	DYNAMIC bool __fastcall IsEqual(TCustomRVParaInfo* Value, const TRVParaInfoProperties &IgnoreList);
	DYNAMIC void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	DYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	bool __fastcall IsHeading(int MaxLevel);
	
__published:
	__property int NextParaNo = {read=FNextParaNo, write=FNextParaNo, default=-1};
	__property int DefStyleNo = {read=FDefStyleNo, write=FDefStyleNo, default=-1};
	__property TRVParaInfoProperties1 ModifiedProperties1 = {read=FModifiedProperties1, write=FModifiedProperties1, default=0};
	__property TRVParaInfoProperties2 ModifiedProperties2 = {read=FModifiedProperties2, write=FModifiedProperties2, default=0};
public:
	/* TCustomRVParaInfo.Destroy */ inline __fastcall virtual ~TParaInfo(void) { }
	
};


class DELPHICLASS TErrParaInfo;
class PASCALIMPLEMENTATION TErrParaInfo : public TParaInfo
{
	typedef TParaInfo inherited;
	
private:
	TRVStyle* FRVStyle;
	
public:
	__fastcall TErrParaInfo(TRVStyle* RVStyle);
	virtual TRVStyle* __fastcall GetRVStyle(void);
public:
	/* TParaInfo.Create */ inline __fastcall virtual TErrParaInfo(Classes::TCollection* Collection) : TParaInfo(Collection) { }
	
public:
	/* TCustomRVParaInfo.Destroy */ inline __fastcall virtual ~TErrParaInfo(void) { }
	
};


class DELPHICLASS TParaInfos;
class PASCALIMPLEMENTATION TParaInfos : public TCustomRVInfos
{
	typedef TCustomRVInfos inherited;
	
public:
	TParaInfo* operator[](int Index) { return Items[Index]; }
	
private:
	TParaInfo* FInvalidItem;
	HIDESBASE TParaInfo* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, TParaInfo* Value);
	TParaInfo* __fastcall GetInvalidItem(void);
	void __fastcall SetInvalidItem(const TParaInfo* Value);
	
public:
	HIDESBASE TParaInfo* __fastcall Add(void);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	__fastcall virtual ~TParaInfos(void);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section);
	int __fastcall FindSuchStyle(int BaseStyle, TParaInfo* Style, const TRVParaInfoProperties &Mask);
	int __fastcall FindStyleWithAlignment(int BaseStyle, TRVAlignment Alignment);
	__property TParaInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	__property TParaInfo* InvalidItem = {read=GetInvalidItem, write=SetInvalidItem};
public:
	/* TCustomRVInfos.Create */ inline __fastcall TParaInfos(Classes::TCollectionItemClass ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
	
};


class DELPHICLASS TRVMarkerFont;
class PASCALIMPLEMENTATION TRVMarkerFont : public Graphics::TFont
{
	typedef Graphics::TFont inherited;
	
private:
	bool __fastcall StoreName(void);
	bool __fastcall StoreHeight(void);
	
public:
	__fastcall TRVMarkerFont(void);
	bool __fastcall IsEqual(Graphics::TFont* Font);
	bool __fastcall IsDefault(void);
	
__published:
	__property Charset = {default=1};
	__property Color = {default=-16777208};
	__property Name = {stored=StoreName};
	__property Style = {default=0};
	__property Height = {stored=StoreHeight};
public:
	/* TFont.Destroy */ inline __fastcall virtual ~TRVMarkerFont(void) { }
	
};


class DELPHICLASS TRVListLevel;
class PASCALIMPLEMENTATION TRVListLevel : public Classes::TCollectionItem
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TRVListType FListType;
	Graphics::TPicture* FPicture;
	Imglist::TCustomImageList* FImageList;
	int FImageIndex;
	TRVMarkerFormatString FFormatString;
	TRVMarkerFormatStringW FFormatStringW;
	TRVStyleLength FLeftIndent;
	TRVStyleLength FFirstIndent;
	TRVStyleLength FMarkerIndent;
	TRVMarkerAlignment FMarkerAlignment;
	TRVMarkerFont* FFont;
	TRVListLevelOptions FOptions;
	int FStartFrom;
	Graphics::TPicture* __fastcall GetPicture(void);
	void __fastcall SetPicture(const Graphics::TPicture* Value);
	TRVMarkerFont* __fastcall GetFont(void);
	void __fastcall SetFont(const TRVMarkerFont* Value);
	bool __fastcall StoreFont(void);
	bool __fastcall StorePicture(void);
	void __fastcall ImageListTagWriter(Classes::TWriter* Writer);
	void __fastcall ImageListTagReader(Classes::TReader* Reader);
	void __fastcall FormatStringWCodeWriter(Classes::TWriter* Writer);
	void __fastcall FormatStringWCodeReader(Classes::TReader* Reader);
	void __fastcall FormatStringCodeWriter(Classes::TWriter* Writer);
	void __fastcall FormatStringCodeReader(Classes::TReader* Reader);
	void __fastcall FormatStringCodeWReader(Classes::TReader* Reader);
	void __fastcall FormatStringCodeWWriter(Classes::TWriter* Writer);
	bool __fastcall StoreImageList(void);
	Classes::TPersistent* __fastcall GetRVFRVData(void);
	
protected:
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	bool __fastcall IsSimpleEqual(TRVListLevel* Value);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	int __fastcall SimilarityValue(TRVListLevel* Value);
	
public:
	__fastcall virtual TRVListLevel(Classes::TCollection* Collection);
	__fastcall virtual ~TRVListLevel(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	System::UnicodeString __fastcall GetHTMLOpenTagForCSS(void);
	Rvtypes::TRVAnsiString __fastcall GetIndentCSSForTextVersion(TRVStyle* RVStyle);
	void __fastcall HTMLOpenTag(Classes::TStream* Stream, bool UseCSS, TRVStyle* RVStyle);
	void __fastcall HTMLCloseTag(Classes::TStream* Stream, bool UseCSS);
	bool __fastcall HasPicture(void);
	bool __fastcall UsesFont(void);
	bool __fastcall HasNumbering(void);
	bool __fastcall HasVariableWidth(void);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits, TRVStyle* RVStyle);
	
__published:
	__property TRVListType ListType = {read=FListType, write=FListType, default=0};
	__property int StartFrom = {read=FStartFrom, write=FStartFrom, default=1};
	__property Imglist::TCustomImageList* ImageList = {read=FImageList, write=FImageList, stored=StoreImageList};
	__property int ImageIndex = {read=FImageIndex, write=FImageIndex, default=0};
	__property TRVMarkerFormatString FormatString = {read=FFormatString, write=FFormatString, stored=false};
	__property TRVMarkerFormatStringW FormatStringW = {read=FFormatStringW, write=FFormatStringW, stored=false};
	__property TRVStyleLength LeftIndent = {read=FLeftIndent, write=FLeftIndent, default=0};
	__property TRVStyleLength FirstIndent = {read=FFirstIndent, write=FFirstIndent, default=10};
	__property TRVStyleLength MarkerIndent = {read=FMarkerIndent, write=FMarkerIndent, default=0};
	__property TRVMarkerAlignment MarkerAlignment = {read=FMarkerAlignment, write=FMarkerAlignment, default=0};
	__property Graphics::TPicture* Picture = {read=GetPicture, write=SetPicture, stored=StorePicture};
	__property TRVMarkerFont* Font = {read=GetFont, write=SetFont, stored=StoreFont};
	__property TRVListLevelOptions Options = {read=FOptions, write=FOptions, default=3};
};


class DELPHICLASS TRVListLevelCollection;
class PASCALIMPLEMENTATION TRVListLevelCollection : public Classes::TCollection
{
	typedef Classes::TCollection inherited;
	
public:
	TRVListLevel* operator[](int Index) { return Items[Index]; }
	
private:
	Classes::TPersistent* FOwner;
	HIDESBASE TRVListLevel* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TRVListLevel* Value);
	
public:
	__fastcall TRVListLevelCollection(Classes::TPersistent* Owner);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	HIDESBASE TRVListLevel* __fastcall Add(void);
	HIDESBASE TRVListLevel* __fastcall Insert(int Index);
	bool __fastcall IsSimpleEqual(TRVListLevelCollection* Value);
	void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits, TRVStyle* RVStyle);
	__property TRVListLevel* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TRVListLevelCollection(void) { }
	
};


class DELPHICLASS TRVListInfo;
class PASCALIMPLEMENTATION TRVListInfo : public TCustomRVInfo
{
	typedef TCustomRVInfo inherited;
	
private:
	TRVListLevelCollection* FLevels;
	bool FOneLevelPreview;
	int FListID;
	void __fastcall SetLevels(const TRVListLevelCollection* Value);
	int __fastcall GetListID(void);
	void __fastcall ReadListID(Classes::TReader* Reader);
	void __fastcall WriteListID(Classes::TWriter* Writer);
	
protected:
	DYNAMIC int __fastcall SimilarityValue(TCustomRVInfo* Value);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	
public:
	DYNAMIC bool __fastcall IsSimpleEqual(TCustomRVInfo* Value, bool IgnoreReferences, bool IgnoreID = true);
	DYNAMIC bool __fastcall IsSimpleEqualEx(TCustomRVInfo* Value, Rvclasses::TRVIntegerList* Mapping);
	__fastcall virtual TRVListInfo(Classes::TCollection* Collection);
	__fastcall virtual ~TRVListInfo(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	HIDESBASEDYNAMIC void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section, const System::UnicodeString fs);
	bool __fastcall HasNumbering(void);
	bool __fastcall AllNumbered(void);
	bool __fastcall HasVariableWidth(void);
	__property int ListID = {read=GetListID, nodefault};
	DYNAMIC void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits);
	
__published:
	__property TRVListLevelCollection* Levels = {read=FLevels, write=SetLevels};
	__property bool OneLevelPreview = {read=FOneLevelPreview, write=FOneLevelPreview, default=0};
};


class DELPHICLASS TRVListInfos;
class PASCALIMPLEMENTATION TRVListInfos : public TCustomRVInfos
{
	typedef TCustomRVInfos inherited;
	
public:
	TRVListInfo* operator[](int Index) { return Items[Index]; }
	
private:
	HIDESBASE TRVListInfo* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TRVListInfo* Value);
	void __fastcall RemoveImageList(Imglist::TCustomImageList* ImageList);
	
public:
	Classes::TPersistent* FRVData;
	bool FRichViewAllowAssignListID;
	HIDESBASE TRVListInfo* __fastcall Add(void);
	HIDESBASE TRVListInfo* __fastcall Insert(int Index);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const System::UnicodeString Section);
	int __fastcall FindSuchStyle(TRVListInfo* Style, bool AddIfNotFound);
	int __fastcall FindStyleWithLevels(TRVListLevelCollection* Levels, const System::UnicodeString StyleNameForAdding, bool AddIfNotFound);
	__property TRVListInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
public:
	/* TCustomRVInfos.Create */ inline __fastcall TRVListInfos(Classes::TCollectionItemClass ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
	
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TRVListInfos(void) { }
	
};


typedef TMetaClass* TRVFontInfoClass;

typedef TMetaClass* TRVParaInfoClass;

typedef TMetaClass* TRVListInfoClass;

class DELPHICLASS TRVSTFontInfo;
class PASCALIMPLEMENTATION TRVSTFontInfo : public TCustomRVFontInfo
{
	typedef TCustomRVFontInfo inherited;
	
private:
	Classes::TPersistent* FOwner;
	void __fastcall SetNoProp(const int Value);
	
public:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
__published:
	__property int StyleTemplateId = {write=SetNoProp, nodefault};
	__property int StyleName = {write=SetNoProp, nodefault};
	__property int Standard = {write=SetNoProp, nodefault};
	__property int BaseStyleNo = {write=SetNoProp, nodefault};
public:
	/* TCustomRVFontInfo.Create */ inline __fastcall virtual TRVSTFontInfo(Classes::TCollection* Collection) : TCustomRVFontInfo(Collection) { }
	
public:
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRVSTFontInfo(void) { }
	
};


class DELPHICLASS TRVSTParaInfo;
class PASCALIMPLEMENTATION TRVSTParaInfo : public TCustomRVParaInfo
{
	typedef TCustomRVParaInfo inherited;
	
private:
	Classes::TPersistent* FOwner;
	void __fastcall SetNoProp(const int Value);
	
public:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
__published:
	__property int StyleTemplateId = {write=SetNoProp, nodefault};
	__property int StyleName = {write=SetNoProp, nodefault};
	__property int Standard = {write=SetNoProp, nodefault};
	__property int BaseStyleNo = {write=SetNoProp, nodefault};
public:
	/* TCustomRVParaInfo.Create */ inline __fastcall virtual TRVSTParaInfo(Classes::TCollection* Collection) : TCustomRVParaInfo(Collection) { }
	/* TCustomRVParaInfo.Destroy */ inline __fastcall virtual ~TRVSTParaInfo(void) { }
	
};


class DELPHICLASS TRVSTListInfo;
class PASCALIMPLEMENTATION TRVSTListInfo : public TRVListInfo
{
	typedef TRVListInfo inherited;
	
private:
	Classes::TPersistent* FOwner;
	void __fastcall SetNoProp(const int Value);
	
public:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
__published:
	__property int StyleTemplateId = {write=SetNoProp, nodefault};
	__property int StyleName = {write=SetNoProp, nodefault};
	__property int Standard = {write=SetNoProp, nodefault};
	__property int BaseStyleNo = {write=SetNoProp, nodefault};
public:
	/* TRVListInfo.Create */ inline __fastcall virtual TRVSTListInfo(Classes::TCollection* Collection) : TRVListInfo(Collection) { }
	/* TRVListInfo.Destroy */ inline __fastcall virtual ~TRVSTListInfo(void) { }
	
};


class DELPHICLASS TRVStyleTemplate;
class PASCALIMPLEMENTATION TRVStyleTemplate : public Classes::TCollectionItem
{
	typedef Classes::TCollectionItem inherited;
	
private:
	TRVStyleTemplateName FName;
	TRVStyleTemplateId FId;
	TRVStyleTemplateId FParentId;
	TRVSTFontInfo* FTextStyle;
	TRVSTParaInfo* FParaStyle;
	TRVSTListInfo* FListStyle;
	TRVFontInfoProperties1 FValidTextProperties1;
	TRVFontInfoProperties2 FValidTextProperties2;
	TRVParaInfoProperties1 FValidParaProperties1;
	TRVParaInfoProperties2 FValidParaProperties2;
	TRVStyleTemplate* FParent;
	Classes::TList* FChildren;
	TRVStyleTemplateId __fastcall GetId(void);
	void __fastcall SetTextStyle(const TRVSTFontInfo* Value);
	void __fastcall SetParaStyle(const TRVSTParaInfo* Value);
	void __fastcall ReadID(Classes::TReader* Reader);
	void __fastcall WriteID(Classes::TWriter* Writer);
	void __fastcall AddChild(TRVStyleTemplate* Child);
	void __fastcall RemoveChild(TRVStyleTemplate* Child);
	void __fastcall SetParentId(const TRVStyleTemplateId Value);
	void __fastcall UpdateParentReference(void);
	void __fastcall SetName(const TRVStyleTemplateName Value);
	
protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	TRVFontInfoProperties __fastcall AssignToTextStyle(TCustomRVFontInfo* ATextStyle, TRVFontInfoProperties AllowedProps);
	TRVParaInfoProperties __fastcall AssignToParaStyle(TCustomRVParaInfo* AParaStyle, const TRVParaInfoProperties &AllowedProps);
	virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
	
public:
	__fastcall virtual TRVStyleTemplate(Classes::TCollection* Collection);
	__fastcall virtual ~TRVStyleTemplate(void);
	virtual System::UnicodeString __fastcall GetDisplayName(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	bool __fastcall IsAncestorFor(TRVStyleTemplate* StyleTemplate);
	void __fastcall ExcludeUnmodifiedTextStyleProperties(TFontInfo* ATextStyle, TRVFontInfoProperties PossibleProps);
	void __fastcall ExcludeUnmodifiedParaStyleProperties(TParaInfo* AParaStyle, const TRVParaInfoProperties &PossibleProps);
	void __fastcall ApplyToTextStyle(TCustomRVFontInfo* ATextStyle, TCustomRVParaInfo* AParaStyle, bool OverrideModifiedProperties);
	void __fastcall ApplyToParaStyle(TCustomRVParaInfo* AParaStyle, bool OverrideModifiedProperties);
	
__published:
	__property TRVSTFontInfo* TextStyle = {read=FTextStyle, write=SetTextStyle};
	__property TRVSTParaInfo* ParaStyle = {read=FParaStyle, write=SetParaStyle};
	__property TRVFontInfoProperties1 ValidTextProperties1 = {read=FValidTextProperties1, write=FValidTextProperties1, default=0};
	__property TRVFontInfoProperties2 ValidTextProperties2 = {read=FValidTextProperties2, write=FValidTextProperties2, default=0};
	__property TRVParaInfoProperties1 ValidParaProperties1 = {read=FValidParaProperties1, write=FValidParaProperties1, default=0};
	__property TRVParaInfoProperties2 ValidParaProperties2 = {read=FValidParaProperties2, write=FValidParaProperties2, default=0};
	__property TRVStyleTemplateName Name = {read=FName, write=SetName};
	__property TRVStyleTemplateId Id = {read=GetId, nodefault};
	__property TRVStyleTemplateId ParentId = {read=FParentId, write=SetParentId, default=-1};
};


class DELPHICLASS TRVStyleTemplateCollection;
class PASCALIMPLEMENTATION TRVStyleTemplateCollection : public Classes::TCollection
{
	typedef Classes::TCollection inherited;
	
public:
	TRVStyleTemplate* operator[](int Index) { return Items[Index]; }
	
private:
	int FNameCounter;
	System::UnicodeString FDefStyleName;
	TRVStyleTemplate* FNormalStyleTemplate;
	HIDESBASE TRVStyleTemplate* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TRVStyleTemplate* Value);
	void __fastcall AssignUniqueNameTo(TRVStyleTemplate* Item);
	bool __fastcall StoreDefStyleName(void);
	void __fastcall UpdateParentReferences(void);
	
protected:
	Classes::TPersistent* FOwner;
	
public:
	__fastcall TRVStyleTemplateCollection(Classes::TPersistent* Owner);
	void __fastcall ResetNameCounter(void);
	void __fastcall Sort(void);
	int __fastcall FindById(TRVStyleTemplateId Id);
	int __fastcall FindByName(const TRVStyleTemplateName Name);
	TRVStyleTemplate* __fastcall GetNormalStyleTemplate(void);
	void __fastcall AssignToStrings(Classes::TStrings* Strings, bool AssignObjects);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall AssignStyleTemplates(TRVStyleTemplateCollection* Source, bool CopyIds);
	void __fastcall ClearParaFormat(TCustomRVParaInfo* AParaStyle);
	void __fastcall ClearTextFormat(TCustomRVFontInfo* ATextStyle, TCustomRVParaInfo* AParaStyle);
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	__property TRVStyleTemplate* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
	
__published:
	__property System::UnicodeString DefStyleName = {read=FDefStyleName, write=FDefStyleName, stored=StoreDefStyleName};
public:
	/* TCollection.Destroy */ inline __fastcall virtual ~TRVStyleTemplateCollection(void) { }
	
};


class PASCALIMPLEMENTATION TRVStyle : public Classes::TComponent
{
	typedef Classes::TComponent inherited;
	
private:
	Graphics::TPicture* FInvalidPicture;
	Graphics::TColor FColor;
	Graphics::TColor FHoverColor;
	Graphics::TColor FCurrentItemColor;
	Graphics::TColor FSelColor;
	Graphics::TColor FSelTextColor;
	Graphics::TColor FInactiveSelColor;
	Graphics::TColor FInactiveSelTextColor;
	Graphics::TColor FCheckpointColor;
	Graphics::TColor FCheckpointEvColor;
	Controls::TCursor FJumpCursor;
	TFontInfos* FTextStyles;
	TParaInfos* FParaStyles;
	TRVListInfos* FListStyles;
	bool FFullRedraw;
	int FSpacesInTab;
	TRVStyleLength FDefTabWidth;
	Graphics::TColor FPageBreakColor;
	Graphics::TColor FSoftPageBreakColor;
	Graphics::TColor FLiveSpellingColor;
	TRVApplyStyleColorEvent FOnApplyStyleColor;
	TRVApplyStyleEvent FOnApplyStyle;
	TRVAfterApplyStyleEvent FOnAfterApplyStyle;
	TRVDrawStyleTextEvent FOnDrawStyleText;
	TRVStyleHoverSensitiveEvent FOnStyleHoverSensitive;
	TRVDrawTextBackEvent FOnDrawTextBack;
	TRVDrawCheckpointEvent FOnDrawCheckpoint;
	TRVDrawPageBreakEvent FOnDrawPageBreak;
	TRVDrawParaRectEvent FOnDrawParaBack;
	Graphics::TColor FFieldHighlightColor;
	Graphics::TColor FDisabledFontColor;
	TRVFieldHighlightType FFieldHighlightType;
	TRVSeqType FFootnoteNumbering;
	TRVSeqType FEndnoteNumbering;
	bool FFootnotePageReset;
	bool FDefaultUnicodeStyles;
	int FDefUnicodeStyle;
	TRVCodePage FDefCodePage;
	bool FUseSound;
	TRVSelectionMode FSelectionMode;
	TRVSelectionStyle FSelectionStyle;
	Controls::TCursor FLineSelectCursor;
	Graphics::TColor FFloatingLineColor;
	Graphics::TColor FSpecialCharactersColor;
	TRVLineWrapMode FLineWrapMode;
	TRVStyleTemplateCollection* FStyleTemplates;
	Rvgrin::TRVGraphicInterface* FGraphicInterface;
	TRVStyleUnits FUnits;
	void __fastcall SetTextStyles(TFontInfos* Value);
	void __fastcall SetParaStyles(TParaInfos* Value);
	void __fastcall SetListStyles(TRVListInfos* Value);
	Graphics::TColor __fastcall GetHoverColorByColor(Graphics::TColor Color);
	Graphics::TPicture* __fastcall GetInvalidPicture(void);
	void __fastcall SetInvalidPicture(const Graphics::TPicture* Value);
	void __fastcall SetStyleTemplates(const TRVStyleTemplateCollection* Value);
	
protected:
	virtual void __fastcall ReadState(Classes::TReader* Reader);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall Loaded(void);
	DYNAMIC void __fastcall CreateGraphicInterface(void);
	
public:
	int ItemNo;
	int OffsetInItem;
	Classes::TPersistent* RVData;
	void __fastcall ResetTextStyles(void);
	void __fastcall ResetParaStyles(void);
	__fastcall virtual TRVStyle(Classes::TComponent* AOwner);
	__fastcall virtual ~TRVStyle(void);
	virtual TRVFontInfoClass __fastcall GetTextStyleClass(void);
	virtual TRVParaInfoClass __fastcall GetParaStyleClass(void);
	virtual TRVListInfoClass __fastcall GetListStyleClass(void);
	void __fastcall GetNextTab(int ParaNo, int X, const TRVScreenAndDevice &sad, int &Position, System::UnicodeString &Leader, TRVTabAlign &Align, Rvscroll::TRVBiDiMode DefBiDiMode, int LeftIndent, int RightIndent);
	int __fastcall AddTextStyle [[deprecated]](void);
	void __fastcall DeleteTextStyle [[deprecated]](int Index);
	void __fastcall SaveINI(const System::UnicodeString FileName, const System::UnicodeString Section);
	void __fastcall LoadINI(const System::UnicodeString FileName, const System::UnicodeString Section);
	void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, System::UnicodeString Section);
	void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, System::UnicodeString Section);
	void __fastcall SaveReg(const System::UnicodeString BaseKey);
	void __fastcall LoadReg(const System::UnicodeString BaseKey);
	void __fastcall SaveCSSToStream(Classes::TStream* Stream, TRVSaveCSSOptions AOptions);
	bool __fastcall SaveCSS(const System::UnicodeString FileName, TRVSaveCSSOptions AOptions);
	Rvtypes::TRVAnsiString __fastcall GetCSSSize(TRVStyleLength Value);
	Graphics::TColor __fastcall GetHoverColor(int StyleNo);
	void __fastcall DrawTextBack(Graphics::TCanvas* Canvas, int ItemNo, int StyleNo, Classes::TPersistent* RVData, int Left, int Top, int Width, int Height, TRVTextDrawStates DrawState);
	void __fastcall ApplyStyle(Graphics::TCanvas* Canvas, int StyleNo, Rvscroll::TRVBiDiMode DefBiDiMode, bool CanUseCustomPPI, PRVExtraFontInfo ExtraFontInfo, bool IgnoreSubSuperScript, bool ToFormatCanvas);
	void __fastcall ApplyStyleColor(Graphics::TCanvas* Canvas, int StyleNo, TRVTextDrawStates DrawState, bool Printing, TRVColorMode ColorMode);
	void __fastcall DrawStyleText(const Rvtypes::TRVRawByteString s, Graphics::TCanvas* Canvas, int ItemNo, int OffsetInItem, int StyleNo, Classes::TPersistent* RVData, int SpaceBefore, int Left, int Top, int Width, int Height, int BaseLine, TRVTextDrawStates DrawState, bool Printing, bool PreviewCorrection, TRVColorMode ColorMode, Rvscroll::TRVBiDiMode DefBiDiMode, Graphics::TCanvas* RefCanvas);
	void __fastcall DrawCheckpoint(Graphics::TCanvas* Canvas, int X, int Y, int AreaLeft, int Width, Classes::TPersistent* RVData, int ItemNo, int XShift, bool RaiseEvent, Controls::TControl* Control);
	void __fastcall DrawPageBreak(Graphics::TCanvas* Canvas, int Y, int XShift, TRVPageBreakType PageBreakType, Controls::TControl* Control, Classes::TPersistent* RVData, int ItemNo);
	void __fastcall DrawParaBack(Graphics::TCanvas* Canvas, int ParaNo, const Types::TRect &Rect, bool Printing, TRVColorMode ColorMode);
	bool __fastcall StyleHoverSensitive(int StyleNo);
	int __fastcall GetAsPixels(TRVStyleLength Value);
	int __fastcall GetAsDevicePixelsX(TRVStyleLength Value, PRVScreenAndDevice PSaD);
	int __fastcall GetAsDevicePixelsY(TRVStyleLength Value, PRVScreenAndDevice PSaD);
	int __fastcall GetAsTwips(TRVStyleLength Value);
	TRVStyleLength __fastcall GetAsDifferentUnits(TRVStyleLength Value, TRVStyleUnits Units);
	System::Extended __fastcall GetAsPoints(TRVStyleLength Value);
	TRVLength __fastcall GetAsRVUnits(TRVStyleLength Value, TRVUnits RVUnits);
	TRVStyleLength __fastcall TwipsToUnits(int Value);
	TRVStyleLength __fastcall PixelsToUnits(int Value);
	TRVStyleLength __fastcall DifferentUnitsToUnits(TRVStyleLength Value, TRVStyleUnits Units);
	TRVStyleLength __fastcall RVUnitsToUnits(TRVLength Value, TRVUnits RVUnits);
	__classmethod int __fastcall GetAsPixelsEx(TRVStyleLength Value, TRVStyleUnits Units);
	__classmethod int __fastcall GetAsTwipsEx(TRVStyleLength Value, TRVStyleUnits Units);
	__classmethod TRVLength __fastcall GetAsRVUnitsEx(TRVStyleLength Value, TRVStyleUnits Units, TRVUnits RVUnits);
	__classmethod TRVStyleLength __fastcall RVUnitsToUnitsEx(TRVLength Value, TRVUnits RVUnits, TRVStyleUnits Units);
	__classmethod TRVStyleLength __fastcall TwipsToUnitsEx(int Value, TRVStyleUnits Units);
	__classmethod TRVStyleLength __fastcall PixelsToUnitsEx(int Value, TRVStyleUnits Units);
	__classmethod int __fastcall RVUnitsToPixels(TRVLength Value, TRVUnits RVUnits);
	__classmethod TRVLength __fastcall PixelsToRVUnits(int Value, TRVUnits RVUnits);
	__classmethod int __fastcall PixelsToTwips(int Value);
	__classmethod int __fastcall TwipsToPixels(int Value);
	void __fastcall ConvertToDifferentUnits(TRVStyleUnits NewUnits);
	void __fastcall ConvertToTwips(void);
	void __fastcall ConvertToPixels(void);
	__property bool DefaultUnicodeStyles = {read=FDefaultUnicodeStyles, write=FDefaultUnicodeStyles, nodefault};
	__property Rvgrin::TRVGraphicInterface* GraphicInterface = {read=FGraphicInterface};
	
__published:
	__property TFontInfos* TextStyles = {read=FTextStyles, write=SetTextStyles};
	__property TParaInfos* ParaStyles = {read=FParaStyles, write=SetParaStyles};
	__property TRVListInfos* ListStyles = {read=FListStyles, write=SetListStyles};
	__property int SpacesInTab = {read=FSpacesInTab, write=FSpacesInTab, default=0};
	__property TRVStyleLength DefTabWidth = {read=FDefTabWidth, write=FDefTabWidth, default=48};
	__property Controls::TCursor JumpCursor = {read=FJumpCursor, write=FJumpCursor, default=101};
	__property Controls::TCursor LineSelectCursor = {read=FLineSelectCursor, write=FLineSelectCursor, default=106};
	__property bool FullRedraw = {read=FFullRedraw, write=FFullRedraw, default=0};
	__property bool UseSound = {read=FUseSound, write=FUseSound, default=1};
	__property Graphics::TColor Color = {read=FColor, write=FColor, default=-16777211};
	__property Graphics::TColor HoverColor = {read=FHoverColor, write=FHoverColor, default=536870911};
	__property Graphics::TColor CurrentItemColor = {read=FCurrentItemColor, write=FCurrentItemColor, default=536870911};
	__property Graphics::TColor SelColor = {read=FSelColor, write=FSelColor, default=-16777203};
	__property Graphics::TColor SelTextColor = {read=FSelTextColor, write=FSelTextColor, default=-16777202};
	__property Graphics::TColor InactiveSelColor = {read=FInactiveSelColor, write=FInactiveSelColor, default=-16777203};
	__property Graphics::TColor InactiveSelTextColor = {read=FInactiveSelTextColor, write=FInactiveSelTextColor, default=-16777202};
	__property Graphics::TColor CheckpointColor = {read=FCheckpointColor, write=FCheckpointColor, default=32768};
	__property Graphics::TColor CheckpointEvColor = {read=FCheckpointEvColor, write=FCheckpointEvColor, default=65280};
	__property Graphics::TColor PageBreakColor = {read=FPageBreakColor, write=FPageBreakColor, default=-16777200};
	__property Graphics::TColor SoftPageBreakColor = {read=FSoftPageBreakColor, write=FSoftPageBreakColor, default=-16777201};
	__property Graphics::TColor LiveSpellingColor = {read=FLiveSpellingColor, write=FLiveSpellingColor, default=255};
	__property Graphics::TColor FloatingLineColor = {read=FFloatingLineColor, write=FFloatingLineColor, default=12427914};
	__property Graphics::TColor SpecialCharactersColor = {read=FSpecialCharactersColor, write=FSpecialCharactersColor, default=536870911};
	__property TRVSelectionMode SelectionMode = {read=FSelectionMode, write=FSelectionMode, default=1};
	__property TRVSelectionStyle SelectionStyle = {read=FSelectionStyle, write=FSelectionStyle, default=0};
	__property Graphics::TColor FieldHighlightColor = {read=FFieldHighlightColor, write=FFieldHighlightColor, default=-16777201};
	__property TRVFieldHighlightType FieldHighlightType = {read=FFieldHighlightType, write=FFieldHighlightType, default=1};
	__property Graphics::TColor DisabledFontColor = {read=FDisabledFontColor, write=FDisabledFontColor, default=536870911};
	__property TRVSeqType FootnoteNumbering = {read=FFootnoteNumbering, write=FFootnoteNumbering, default=0};
	__property TRVSeqType EndnoteNumbering = {read=FEndnoteNumbering, write=FEndnoteNumbering, default=3};
	__property bool FootnotePageReset = {read=FFootnotePageReset, write=FFootnotePageReset, default=1};
	__property TRVLineWrapMode LineWrapMode = {read=FLineWrapMode, write=FLineWrapMode, default=2};
	__property int DefUnicodeStyle = {read=FDefUnicodeStyle, write=FDefUnicodeStyle, default=-1};
	__property TRVCodePage DefCodePage = {read=FDefCodePage, write=FDefCodePage, default=0};
	__property Graphics::TPicture* InvalidPicture = {read=GetInvalidPicture, write=SetInvalidPicture};
	__property TRVStyleUnits Units = {read=FUnits, write=FUnits, default=0};
	__property TRVApplyStyleEvent OnApplyStyle = {read=FOnApplyStyle, write=FOnApplyStyle};
	__property TRVAfterApplyStyleEvent OnAfterApplyStyle = {read=FOnAfterApplyStyle, write=FOnAfterApplyStyle};
	__property TRVApplyStyleColorEvent OnApplyStyleColor = {read=FOnApplyStyleColor, write=FOnApplyStyleColor};
	__property TRVDrawStyleTextEvent OnDrawStyleText = {read=FOnDrawStyleText, write=FOnDrawStyleText};
	__property TRVStyleHoverSensitiveEvent OnStyleHoverSensitive = {read=FOnStyleHoverSensitive, write=FOnStyleHoverSensitive};
	__property TRVDrawTextBackEvent OnDrawTextBack = {read=FOnDrawTextBack, write=FOnDrawTextBack};
	__property TRVDrawCheckpointEvent OnDrawCheckpoint = {read=FOnDrawCheckpoint, write=FOnDrawCheckpoint};
	__property TRVDrawPageBreakEvent OnDrawPageBreak = {read=FOnDrawPageBreak, write=FOnDrawPageBreak};
	__property TRVDrawParaRectEvent OnDrawParaBack = {read=FOnDrawParaBack, write=FOnDrawParaBack};
	__property TRVStyleTemplateCollection* StyleTemplates = {read=FStyleTemplates, write=SetStyleTemplates};
};


//-- var, const, procedure ---------------------------------------------------
static const ShortInt crJump = 0x65;
static const ShortInt crRVFlipArrow = 0x6a;
static const ShortInt rvsNormal = 0x0;
static const ShortInt rvsHeading = 0x1;
static const ShortInt rvsSubheading = 0x2;
static const ShortInt rvsKeyword = 0x3;
static const ShortInt rvsJump1 = 0x4;
static const ShortInt rvsJump2 = 0x5;
static const ShortInt rvsBreak = -1;
static const ShortInt rvsCheckpoint = -2;
static const ShortInt rvsPicture = -3;
static const ShortInt rvsHotspot = -4;
static const ShortInt rvsComponent = -5;
static const ShortInt rvsBullet = -6;
static const ShortInt rvsBack = -7;
static const ShortInt rvsVersionInfo = -8;
static const ShortInt rvsDocProperty = -9;
static const ShortInt rvsHotPicture = -10;
static const ShortInt rvsListMarker = -11;
static const ShortInt rvsTab = -12;
static const ShortInt LAST_DEFAULT_STYLE_NO = 0x5;
static const int rvsDefStyle = 2147483647;
static const int DEFAULT_FLOATINGLINECOLOR = 0xbda28a;
extern PACKAGE TRVRTFOptions rvrtfDefault;
extern PACKAGE TRVFontInfoProperties RVAllFontInfoProperties;
extern PACKAGE TRVParaInfoProperties RVAllParaInfoProperties;
extern PACKAGE TRVParaInfoProperties RVAllParaInfoProperties1;
extern PACKAGE TRVParaInfoProperties RVAllParaInfoProperties2;
extern PACKAGE TRVParaInfoProperties RVAllParaBackgroundProperties;
extern PACKAGE TRVParaInfoProperties RVAllParaBorderProperties;
extern PACKAGE bool RichViewResetStandardFlag;
extern PACKAGE bool RVNoLstIDProperty;
extern PACKAGE bool RichViewCompareStyleNames;
extern PACKAGE TRVSpecialCharacters RVVisibleSpecialCharacters;
extern PACKAGE TRVParagraphMarks RVParagraphMarks;
extern PACKAGE int RVFORMATCANVASFACTOR;
extern PACKAGE int RVFORMATCANVASRESOLUTION;
extern PACKAGE bool ScaleRichViewTextDrawAlwaysUseGlyphs;
extern PACKAGE int __fastcall RVConvertFromFormatCanvas(int V, bool UseFormatCanvas);
extern PACKAGE int __fastcall RVConvertToFormatCanvas(int V, bool UseFormatCanvas);
extern PACKAGE void __fastcall RVDrawUnderline(Graphics::TCanvas* Canvas, TRVUnderlineType UnderlineType, Graphics::TColor Color, int Left, int Right, int Y, int BaseLineWidth, Rvgrin::TRVGraphicInterface* GraphicInterface);
extern PACKAGE void __fastcall RVDrawHiddenUnderline(Graphics::TCanvas* Canvas, Graphics::TColor Color, int Left, int Right, int Y, Rvgrin::TRVGraphicInterface* GraphicInterface);
extern PACKAGE void __fastcall RVWrite(Classes::TStream* Stream, const Rvtypes::TRVAnsiString s);
extern PACKAGE void __fastcall RVWriteLn(Classes::TStream* Stream, const Rvtypes::TRVAnsiString s);
extern PACKAGE void __fastcall RVWriteX(Classes::TStream* Stream, const Rvtypes::TRVAnsiString s, bool Multiline);

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

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