david
fddb8c1dff
NO HAY CÓDIGO FUENTE git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.TRichView@1 b34d35ef-135b-4489-b9d1-9916e9c25524
1470 lines
67 KiB
C++
1470 lines
67 KiB
C++
// Borland C++ Builder
|
|
// Copyright (c) 1995, 2005 by Borland Software Corporation
|
|
// All rights reserved
|
|
|
|
// (DO NOT EDIT: machine generated header) 'Rvstyle.pas' rev: 10.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 <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
|
|
|
|
//-- user supplied -----------------------------------------------------------
|
|
|
|
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 };
|
|
#pragma option pop
|
|
|
|
typedef Set<TRVTextDrawState, rvtsSelected, rvtsSpecialCharacters> 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 AnsiString TRVMarkerFormatString;
|
|
|
|
typedef WideString TRVMarkerFormatStringW;
|
|
|
|
#pragma option push -b-
|
|
enum TRVFOption { rvfoSavePicturesBody, rvfoSaveControlsBody, rvfoIgnoreUnknownPicFmt, rvfoIgnoreUnknownCtrls, rvfoIgnoreUnknownCtrlProperties, rvfoConvUnknownStylesToZero, rvfoConvLargeImageIdxToZero, rvfoSaveBinary, rvfoUseStyleNames, rvfoSaveBack, rvfoLoadBack, rvfoSaveTextStyles, rvfoSaveParaStyles, rvfoSaveLayout, rvfoLoadLayout, rvfoSaveDocProperties, rvfoLoadDocProperties };
|
|
#pragma option pop
|
|
|
|
typedef Set<TRVFOption, rvfoSavePicturesBody, rvfoLoadDocProperties> 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 };
|
|
#pragma option pop
|
|
|
|
typedef Set<TRVFWarning, rvfwUnknownPicFmt, rvfwUnknownCtrlProperties> 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 };
|
|
#pragma option pop
|
|
|
|
typedef Set<TRVTextOption, rvteoHTMLCode, rvteoRTFCode> 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
|
|
|
|
struct TRVExtraFontInfo
|
|
{
|
|
|
|
public:
|
|
int ScriptHeight;
|
|
} ;
|
|
|
|
typedef TRVExtraFontInfo *PRVExtraFontInfo;
|
|
|
|
typedef 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, 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 Set<TRVFontInfoProperty, rvfiFontName, rvfiCustom> TRVFontInfoProperties;
|
|
|
|
typedef Set<TRVParaInfoProperty, rvpiFirstIndent, rvpiCustom> TRVParaInfoProperties;
|
|
|
|
typedef Set<TRVParaInfoProperty1, rvpiFirstIndent, rvpiBorder_Vis_Bottom> TRVParaInfoProperties1;
|
|
|
|
typedef Set<TRVParaInfoProperty2, rvpiNoWrap, rvpiBiDiMode> TRVParaInfoProperties2;
|
|
|
|
#pragma option push -b-
|
|
enum TRVLineSpacingType { rvlsPercent, rvlsSpaceBetween, rvlsLineHeightAtLeast, rvlsLineHeightExact };
|
|
#pragma option pop
|
|
|
|
#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 AnsiString TRVStyleTemplateName;
|
|
|
|
#pragma option push -b-
|
|
enum TRVSpecialCharacter { rvscSpace, rvscNBSP, rvscParagraph, rvscSoftHyphen, rvscParagraphAttrs, rvcFloatingLines };
|
|
#pragma option pop
|
|
|
|
typedef Set<TRVSpecialCharacter, rvscSpace, rvcFloatingLines> TRVSpecialCharacters;
|
|
|
|
#pragma option push -b-
|
|
enum TRVFieldHighlightType { rvfhNever, rvfhCurrent, rvfhAlways };
|
|
#pragma option pop
|
|
|
|
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 AnsiString 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);
|
|
|
|
class DELPHICLASS TCustomRVInfo;
|
|
class PASCALIMPLEMENTATION TCustomRVInfo : public Classes::TCollectionItem
|
|
{
|
|
typedef Classes::TCollectionItem inherited;
|
|
|
|
private:
|
|
int FBaseStyleNo;
|
|
AnsiString 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 AnsiString __fastcall GetDisplayName();
|
|
void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs, const AnsiString DefName);
|
|
|
|
__published:
|
|
__property int BaseStyleNo = {read=FBaseStyleNo, write=FBaseStyleNo, default=-1};
|
|
__property AnsiString StyleName = {read=FName, write=FName};
|
|
__property bool Standard = {read=FStandard, write=FStandard, default=1};
|
|
__property TRVStyleTemplateId StyleTemplateId = {read=FStyleTemplateId, write=FStyleTemplateId, default=-1};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Destroy */ inline __fastcall virtual ~TCustomRVInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TCustomRVFontInfo;
|
|
class PASCALIMPLEMENTATION TCustomRVFontInfo : public TCustomRVInfo
|
|
{
|
|
typedef TCustomRVInfo inherited;
|
|
|
|
private:
|
|
Rvscroll::TRVBiDiMode FBiDiMode;
|
|
bool FJump;
|
|
Controls::TCursor FJumpCursor;
|
|
AnsiString 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;
|
|
int 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);
|
|
|
|
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(tagLOGFONTA &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);
|
|
void __fastcall ApplyBiDiMode(Graphics::TCanvas* Canvas, Rvscroll::TRVBiDiMode DefBiDiMode, bool ToFormatCanvas);
|
|
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 AnsiString Section, const AnsiString fs);
|
|
HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString 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);
|
|
|
|
__published:
|
|
__property Graphics::TFontCharset Charset = {read=FCharset, write=FCharset, default=1};
|
|
__property AnsiString 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 int 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:
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Destroy */ inline __fastcall virtual ~TCustomRVFontInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TFontInfo;
|
|
class PASCALIMPLEMENTATION TFontInfo : public TCustomRVFontInfo
|
|
{
|
|
typedef TCustomRVFontInfo inherited;
|
|
|
|
private:
|
|
bool FUnicode;
|
|
int FNextStyleNo;
|
|
TRVFontInfoProperties FModifiedProperties;
|
|
|
|
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 AnsiString s, Graphics::TCanvas* Canvas, int ThisStyleNo, int SpaceBefore, 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);
|
|
void __fastcall DrawVertical(const AnsiString 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 AnsiString Section, const AnsiString fs);
|
|
DYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs, bool JumpByDefault, Controls::TCursor DefJumpCursor);
|
|
|
|
__published:
|
|
__property int NextStyleNo = {read=FNextStyleNo, write=FNextStyleNo, default=-1};
|
|
__property bool Unicode = {read=FUnicode, write=FUnicode, default=0};
|
|
__property TRVFontInfoProperties ModifiedProperties = {read=FModifiedProperties, write=FModifiedProperties, default=0};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Destroy */ inline __fastcall virtual ~TFontInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TCustomRVInfos;
|
|
class PASCALIMPLEMENTATION TCustomRVInfos : public Classes::TCollection
|
|
{
|
|
typedef Classes::TCollection inherited;
|
|
|
|
protected:
|
|
Classes::TPersistent* FOwner;
|
|
|
|
public:
|
|
__fastcall TCustomRVInfos(TMetaClass* 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));
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollection.Destroy */ inline __fastcall virtual ~TCustomRVInfos(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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 AnsiString 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(AnsiString Name, int Size, Graphics::TColor Color, Graphics::TColor BackColor, Graphics::TFontStyles Style);
|
|
TFontInfo* __fastcall AddFontEx(AnsiString Name, int Size, Graphics::TColor Color, Graphics::TColor BackColor, Graphics::TFontStyles Style, Graphics::TFontCharset Charset);
|
|
void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const AnsiString Section);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, Controls::TCursor DefJumpCursor);
|
|
__property TFontInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
|
|
__property TFontInfo* InvalidItem = {read=GetInvalidItem, write=SetInvalidItem};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVInfos.Create */ inline __fastcall TFontInfos(TMetaClass* ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TRVRect;
|
|
class PASCALIMPLEMENTATION TRVRect : public Classes::TPersistent
|
|
{
|
|
typedef Classes::TPersistent inherited;
|
|
|
|
private:
|
|
int FTop;
|
|
int FLeft;
|
|
int FRight;
|
|
int FBottom;
|
|
bool __fastcall IsEqualEx(TRVRect* Value, bool IgnL, bool IgnT, bool IgnR, bool IgnB);
|
|
int __fastcall SimilarityValue(TRVRect* Value, int Weight);
|
|
|
|
public:
|
|
virtual void __fastcall Assign(Classes::TPersistent* Source);
|
|
void __fastcall AssignValidProperties(TRVRect* Source, bool ValL, bool ValT, bool ValR, bool ValB);
|
|
void __fastcall SetAll(int Value);
|
|
void __fastcall InflateRect(Types::TRect &Rect);
|
|
void __fastcall InflateRectSaD(Types::TRect &Rect, 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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
|
|
__published:
|
|
__property int Left = {read=FLeft, write=FLeft, default=0};
|
|
__property int Right = {read=FRight, write=FRight, default=0};
|
|
__property int Top = {read=FTop, write=FTop, default=0};
|
|
__property int Bottom = {read=FBottom, write=FBottom, default=0};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TPersistent.Destroy */ inline __fastcall virtual ~TRVRect(void) { }
|
|
#pragma option pop
|
|
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TObject.Create */ inline __fastcall TRVRect(void) : Classes::TPersistent() { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString 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:
|
|
#pragma option push -w-inl
|
|
/* TPersistent.Destroy */ inline __fastcall virtual ~TRVBooleanRect(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TRVBorder;
|
|
class PASCALIMPLEMENTATION TRVBorder : public Classes::TPersistent
|
|
{
|
|
typedef Classes::TPersistent inherited;
|
|
|
|
private:
|
|
Graphics::TColor FColor;
|
|
TRVBorderStyle FStyle;
|
|
int FWidth;
|
|
int FInternalWidth;
|
|
TRVBooleanRect* FVisibleBorders;
|
|
TRVRect* FBorderOffsets;
|
|
void __fastcall SetBorderOffsets(const TRVRect* Value);
|
|
void __fastcall SetVisibleBorders(const TRVBooleanRect* Value);
|
|
int __fastcall SimilarityValue(TRVBorder* Value);
|
|
|
|
protected:
|
|
void __fastcall DoDraw(const Types::TRect &Rect, Graphics::TCanvas* Canvas, int Width, int InternalWidth, int OnePixelWidth, TRVColorMode ColorMode);
|
|
|
|
public:
|
|
__fastcall TRVBorder(void);
|
|
__fastcall virtual ~TRVBorder(void);
|
|
void __fastcall Draw(const Types::TRect &Rect, Graphics::TCanvas* Canvas);
|
|
void __fastcall DrawSaD(const Types::TRect &Rect, Graphics::TCanvas* Canvas, const TRVScreenAndDevice &sad, TRVColorMode ColorMode);
|
|
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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
int __fastcall GetTotalWidth(void);
|
|
|
|
__published:
|
|
__property int Width = {read=FWidth, write=FWidth, default=1};
|
|
__property int InternalWidth = {read=FInternalWidth, write=FInternalWidth, 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;
|
|
void __fastcall SetBorderOffsets(const TRVRect* Value);
|
|
int __fastcall SimilarityValue(TRVBackgroundRect* Value);
|
|
|
|
public:
|
|
__fastcall TRVBackgroundRect(void);
|
|
__fastcall virtual ~TRVBackgroundRect(void);
|
|
virtual void __fastcall Assign(Classes::TPersistent* Source);
|
|
void __fastcall PrepareDraw(Types::TRect &Rect);
|
|
void __fastcall PrepareDrawSaD(Types::TRect &Rect, const TRVScreenAndDevice &sad);
|
|
void __fastcall Draw(const Types::TRect &Rect, Graphics::TCanvas* Canvas, bool Printing, TRVColorMode ColorMode);
|
|
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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
|
|
__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:
|
|
int FPosition;
|
|
AnsiString FLeader;
|
|
TRVTabAlign FAlign;
|
|
bool __fastcall StoreLeader(void);
|
|
void __fastcall SetPosition(const int Value);
|
|
|
|
protected:
|
|
virtual AnsiString __fastcall GetDisplayName();
|
|
|
|
public:
|
|
bool __fastcall IsEqual(TRVTabInfo* Value);
|
|
int __fastcall SimilarityValue(TRVTabInfo* Value);
|
|
virtual void __fastcall Assign(Classes::TPersistent* Source);
|
|
void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
|
|
__published:
|
|
__property TRVTabAlign Align = {read=FAlign, write=FAlign, default=0};
|
|
__property int Position = {read=FPosition, write=SetPosition, nodefault};
|
|
__property AnsiString Leader = {read=FLeader, write=FLeader, stored=StoreLeader};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Create */ inline __fastcall virtual TRVTabInfo(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
|
|
#pragma option pop
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRVTabInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString 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);
|
|
void __fastcall Intersect(TRVTabInfos* Value);
|
|
void __fastcall AddFrom(TRVTabInfos* Source);
|
|
void __fastcall DeleteList(Rvclasses::TRVIntegerList* Positions);
|
|
__property TRVTabInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollection.Destroy */ inline __fastcall virtual ~TRVTabInfos(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TCustomRVParaInfo;
|
|
class DELPHICLASS TParaInfo;
|
|
class PASCALIMPLEMENTATION TCustomRVParaInfo : public TCustomRVInfo
|
|
{
|
|
typedef TCustomRVInfo inherited;
|
|
|
|
private:
|
|
int FFirstIndent;
|
|
int FLeftIndent;
|
|
int FRightIndent;
|
|
int FSpaceBefore;
|
|
int FSpaceAfter;
|
|
int 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);
|
|
|
|
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 AnsiString Section, const AnsiString fs);
|
|
HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
DYNAMIC bool __fastcall IsEqual(TCustomRVParaInfo* Value, const TRVParaInfoProperties &IgnoreList);
|
|
void __fastcall SaveCSSToStream(Classes::TStream* Stream, TParaInfo* BaseStyle, bool Multiline, bool IgnoreLeftAlignment, bool IgnoreLeftIndents);
|
|
|
|
__published:
|
|
__property int FirstIndent = {read=FFirstIndent, write=FFirstIndent, default=0};
|
|
__property int LeftIndent = {read=FLeftIndent, write=FLeftIndent, default=0};
|
|
__property int RightIndent = {read=FRightIndent, write=FRightIndent, default=0};
|
|
__property int SpaceBefore = {read=FSpaceBefore, write=FSpaceBefore, default=0};
|
|
__property int SpaceAfter = {read=FSpaceAfter, write=FSpaceAfter, 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 int 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 AnsiString Section, const AnsiString fs);
|
|
DYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString 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:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVParaInfo.Destroy */ inline __fastcall virtual ~TParaInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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 AnsiString Section);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString 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:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVInfos.Create */ inline __fastcall TParaInfos(TMetaClass* ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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:
|
|
#pragma option push -w-inl
|
|
/* TFont.Destroy */ inline __fastcall virtual ~TRVMarkerFont(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TRVListLevel;
|
|
class PASCALIMPLEMENTATION TRVListLevel : public Classes::TCollectionItem
|
|
{
|
|
typedef Classes::TCollectionItem inherited;
|
|
|
|
private:
|
|
TRVListType FListType;
|
|
Graphics::TPicture* FPicture;
|
|
Imglist::TCustomImageList* FImageList;
|
|
int FImageIndex;
|
|
AnsiString FFormatString;
|
|
WideString FFormatStringW;
|
|
int FLeftIndent;
|
|
int FFirstIndent;
|
|
int 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);
|
|
bool __fastcall StoreImageList(void);
|
|
Classes::TPersistent* __fastcall GetRVFRVData(void);
|
|
|
|
protected:
|
|
virtual AnsiString __fastcall GetDisplayName();
|
|
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);
|
|
AnsiString __fastcall GetHTMLOpenTagForCSS();
|
|
AnsiString __fastcall GetIndentCSSForTextVersion();
|
|
void __fastcall HTMLOpenTag(Classes::TStream* Stream, bool UseCSS);
|
|
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 AnsiString Section, const AnsiString fs);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
|
|
__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 AnsiString FormatString = {read=FFormatString, write=FFormatString, stored=false};
|
|
__property WideString FormatStringW = {read=FFormatStringW, write=FFormatStringW, stored=false};
|
|
__property int LeftIndent = {read=FLeftIndent, write=FLeftIndent, default=0};
|
|
__property int FirstIndent = {read=FFirstIndent, write=FFirstIndent, default=10};
|
|
__property int 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);
|
|
__property TRVListLevel* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollection.Destroy */ inline __fastcall virtual ~TRVListLevelCollection(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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 AnsiString Section, const AnsiString fs);
|
|
HIDESBASEDYNAMIC void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, const AnsiString Section, const AnsiString fs);
|
|
bool __fastcall HasNumbering(void);
|
|
bool __fastcall AllNumbered(void);
|
|
bool __fastcall HasVariableWidth(void);
|
|
__property int ListID = {read=GetListID, nodefault};
|
|
|
|
__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 AnsiString Section);
|
|
void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, const AnsiString Section);
|
|
int __fastcall FindSuchStyle(TRVListInfo* Style, bool AddIfNotFound);
|
|
int __fastcall FindStyleWithLevels(TRVListLevelCollection* Levels, const AnsiString StyleNameForAdding, bool AddIfNotFound);
|
|
__property TRVListInfo* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVInfos.Create */ inline __fastcall TRVListInfos(TMetaClass* ItemClass, Classes::TPersistent* Owner) : TCustomRVInfos(ItemClass, Owner) { }
|
|
#pragma option pop
|
|
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollection.Destroy */ inline __fastcall virtual ~TRVListInfos(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVFontInfo.Create */ inline __fastcall virtual TRVSTFontInfo(Classes::TCollection* Collection) : TCustomRVFontInfo(Collection) { }
|
|
#pragma option pop
|
|
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollectionItem.Destroy */ inline __fastcall virtual ~TRVSTFontInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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:
|
|
#pragma option push -w-inl
|
|
/* TCustomRVParaInfo.Create */ inline __fastcall virtual TRVSTParaInfo(Classes::TCollection* Collection) : TCustomRVParaInfo(Collection) { }
|
|
#pragma option pop
|
|
#pragma option push -w-inl
|
|
/* TCustomRVParaInfo.Destroy */ inline __fastcall virtual ~TRVSTParaInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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:
|
|
#pragma option push -w-inl
|
|
/* TRVListInfo.Create */ inline __fastcall virtual TRVSTListInfo(Classes::TCollection* Collection) : TRVListInfo(Collection) { }
|
|
#pragma option pop
|
|
#pragma option push -w-inl
|
|
/* TRVListInfo.Destroy */ inline __fastcall virtual ~TRVSTListInfo(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
class DELPHICLASS TRVStyleTemplate;
|
|
class PASCALIMPLEMENTATION TRVStyleTemplate : public Classes::TCollectionItem
|
|
{
|
|
typedef Classes::TCollectionItem inherited;
|
|
|
|
private:
|
|
AnsiString FName;
|
|
TRVStyleTemplateId FId;
|
|
TRVStyleTemplateId FParentId;
|
|
TRVSTFontInfo* FTextStyle;
|
|
TRVSTParaInfo* FParaStyle;
|
|
TRVSTListInfo* FListStyle;
|
|
TRVFontInfoProperties FValidTextProperties;
|
|
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 AnsiString 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 AnsiString __fastcall GetDisplayName();
|
|
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 TRVFontInfoProperties ValidTextProperties = {read=FValidTextProperties, write=FValidTextProperties, default=0};
|
|
__property TRVParaInfoProperties1 ValidParaProperties1 = {read=FValidParaProperties1, write=FValidParaProperties1, default=0};
|
|
__property TRVParaInfoProperties2 ValidParaProperties2 = {read=FValidParaProperties2, write=FValidParaProperties2, default=0};
|
|
__property AnsiString 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;
|
|
AnsiString 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 AnsiString 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 AnsiString DefStyleName = {read=FDefStyleName, write=FDefStyleName, stored=StoreDefStyleName};
|
|
public:
|
|
#pragma option push -w-inl
|
|
/* TCollection.Destroy */ inline __fastcall virtual ~TRVStyleTemplateCollection(void) { }
|
|
#pragma option pop
|
|
|
|
};
|
|
|
|
|
|
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;
|
|
int 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;
|
|
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;
|
|
TRVStyleTemplateCollection* FStyleTemplates;
|
|
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);
|
|
|
|
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 TMetaClass* __fastcall GetTextStyleClass(void);
|
|
virtual TMetaClass* __fastcall GetParaStyleClass(void);
|
|
virtual TMetaClass* __fastcall GetListStyleClass(void);
|
|
void __fastcall GetNextTab(int ParaNo, int X, const TRVScreenAndDevice &sad, int &Position, AnsiString &Leader, TRVTabAlign &Align, Rvscroll::TRVBiDiMode DefBiDiMode, int LeftIndent, int RightIndent);
|
|
int __fastcall AddTextStyle(void);
|
|
void __fastcall DeleteTextStyle(int Index);
|
|
void __fastcall SaveINI(const AnsiString FileName, const AnsiString Section);
|
|
void __fastcall LoadINI(const AnsiString FileName, const AnsiString Section);
|
|
void __fastcall SaveToINI(Inifiles::TCustomIniFile* ini, AnsiString Section);
|
|
void __fastcall LoadFromINI(Inifiles::TCustomIniFile* ini, AnsiString Section);
|
|
void __fastcall SaveReg(const AnsiString BaseKey);
|
|
void __fastcall LoadReg(const AnsiString BaseKey);
|
|
void __fastcall SaveCSSToStream(Classes::TStream* Stream, TRVSaveCSSOptions AOptions);
|
|
bool __fastcall SaveCSS(const AnsiString FileName, TRVSaveCSSOptions AOptions);
|
|
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 AnsiString 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);
|
|
__property bool DefaultUnicodeStyles = {read=FDefaultUnicodeStyles, write=FDefaultUnicodeStyles, nodefault};
|
|
|
|
__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 int 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 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 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 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 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);
|
|
extern PACKAGE void __fastcall RVWrite(Classes::TStream* Stream, const AnsiString s);
|
|
extern PACKAGE void __fastcall RVWriteLn(Classes::TStream* Stream, const AnsiString s);
|
|
extern PACKAGE void __fastcall RVWriteX(Classes::TStream* Stream, const AnsiString s, bool Multiline);
|
|
|
|
} /* namespace Rvstyle */
|
|
using namespace Rvstyle;
|
|
#pragma pack(pop)
|
|
#pragma option pop
|
|
|
|
#pragma delphiheader end.
|
|
//-- end unit ----------------------------------------------------------------
|
|
#endif // Rvstyle
|