source/COM/_StToHTML.pas

(* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is TurboPower SysTools
 *
 * The Initial Developer of the Original Code is
 * TurboPower Software
 *
 * Portions created by the Initial Developer are Copyright (C) 1996-2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * ***** END LICENSE BLOCK ***** *)

{*********************************************************}
{*                  _STTOHTML.PAS 3.00                   *}
{*********************************************************}

{$I STDEFINE.INC}
{$I STCOMDEF.INC}
unit _StToHTML;

interface

uses
  ComObj, ActiveX, AxCtrls, Classes, StStrms, StToHTML, SysTools_TLB, _StUtil, StdVcl;

type
  TStToHTML = class(TAutoObject, IConnectionPointContainer, IStToHTML)
   private  { Private declarations }
    FConnectionPoints: TConnectionPoints;
    FConnectionPoint: TConnectionPoint;
    FSinkList: TList;
    FEvents: IStToHTMLEvents;

    FSourceToHTML  : StToHTML.TStStreamToHTML;
    FKeywords      : IStStringList;
    FCommentMarkers: IStStringList;
    FEmbeddedHTML  : IStStringList;
    FPageFooter    : IStStringList;
    FPageHeader    : IStStringList;
    FStringMarkers : IStStringList;

    FIsLicensed    : Boolean;

    procedure _OnProgress(Sender : TObject; Percent : Word);
   public    { Public declarations }
    procedure Initialize; override;
    destructor Destroy; override;
   protected {Protected declarations }
    { IConnectionPointContainer }
    property ConnectionPoints: TConnectionPoints read FConnectionPoints
      implements IConnectionPointContainer;
    procedure EventSinkChanged(const EventSink: IUnknown); override;

    { IStToHTML properties (GET) }
    function Get_CaseSensitve: WordBool; safecall;
    function Get_CommentMarkers: IStStringList; safecall;
    function Get_EmbeddedHTML: IStStringList; safecall;
    function Get_FixedLineLength: Integer; safecall;
    function Get_Keywords: IStStringList; safecall;
    function Get_LineTermChar: WideString; safecall;
    function Get_LineTerminator: TStLineTerminator; safecall;
    function Get_PageFooter: IStStringList; safecall;
    function Get_PageHeader: IStStringList; safecall;
    function Get_Stream: OleVariant; safecall;
    function Get_StringMarkers: IStStringList; safecall;
    function Get_WordDelimeters: WideString; safecall;

    { IStToHTML properties (SET) }
    procedure Set_CaseSensitve(Value: WordBool); safecall;
    procedure Set_CommentMarkers(const Value: IStStringList); safecall;
    procedure Set_EmbeddedHTML(const Value: IStStringList); safecall;
    procedure Set_FixedLineLength(Value: Integer); safecall;
    procedure Set_Keywords(const Value: IStStringList); safecall;
    procedure Set_LineTermChar(const Value: WideString); safecall;
    procedure Set_LineTerminator(Value: TStLineTerminator); safecall;
    procedure Set_PageFooter(const Value: IStStringList); safecall;
    procedure Set_PageHeader(const Value: IStStringList); safecall;
    procedure Set_Stream(Value: OleVariant); safecall;
    procedure Set_StringMarkers(const Value: IStStringList); safecall;
    procedure Set_WordDelimeters(const Value: WideString); safecall;

    { IStToHTML methods }
    procedure Clear; safecall;
    procedure GenerateHTML; safecall;
    procedure LoadFromFile(const FileName: WideString); safecall;
    procedure SaveToFile(const FileName: WideString); safecall;
    function License(const Key: WideString): WordBool; safecall;
end;

implementation

uses ComServ {$IFDEF LICENSE}, StComLic {$ENDIF};

{ ********** TStSourceToHTML Interface - IConnectionPointContainer Methods *************** }
procedure TStToHTML.EventSinkChanged(const EventSink: IUnknown);
begin
  FEvents := EventSink as IStToHTMLEvents;
  if FConnectionPoint <> nil then
     FSinkList := FConnectionPoint.SinkList;
end;

{ ********** TStSourceToHTML Interface *************************************************** }
procedure TStToHTML.Initialize;
begin
  inherited Initialize;
  FConnectionPoints := TConnectionPoints.Create(Self);
  if AutoFactory.EventTypeInfo <> nil then
    FConnectionPoint := FConnectionPoints.CreateConnectionPoint(
      AutoFactory.EventIID, ckSingle, EventConnect)
  else FConnectionPoint := nil;

  {$IFDEF LICENSE}
  FIsLicensed := False;
  {$ELSE}
  FIsLicensed := True;
  {$ENDIF}

  FSourceToHTML              := StToHTML.TStStreamToHTML.Create;
  FSourceToHTML.InputStream  := Classes.TMemoryStream.Create;
  FSourceToHTML.OutputStream := Classes.TMemoryStream.Create;

  FKeywords       := TStStringList.Create(FSourceToHTML.Keywords);
  FCommentMarkers := TStStringList.Create(FSourceToHTML.CommentMarkers);
  FEmbeddedHTML   := TStStringList.Create(FSourceToHTML.EmbeddedHTML);
  FPageFooter     := TStStringList.Create(FSourceToHTML.PageFooter);
  FPageHeader     := TStStringList.Create(FSourceToHTML.PageHeader);
  FStringMarkers  := TStStringList.Create(FSourceToHTML.StringMarkers);

  FSourceToHTML.OnProgress   := _OnProgress;
end;

destructor TStToHTML.Destroy;
begin
  if Assigned(FSourceToHTML.InputStream) then
    FSourceToHTML.InputStream.Free;

  if Assigned(FSourceToHTML.OutputStream) then
    FSourceToHTML.OutputStream.Free;

  FKeywords       := nil;
  FCommentMarkers := nil;
  FEmbeddedHTML   := nil;
  FPageFooter     := nil;
  FPageHeader     := nil;
  FStringMarkers  := nil;

  FSourceToHTML.Free;

  inherited Destroy;
end;

{ ********** TStSourceToHTML Events ****************************************************** }
procedure TStToHTML._OnProgress(Sender : TObject; Percent : Word);
begin
  if Assigned(FEvents) then
    FEvents.OnProgress(Percent);
end;

{ ********** TStSourceToHTML Properties *** (Get) **************************************** }
function TStToHTML.Get_CaseSensitve: WordBool;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FSourceToHTML.CaseSensitive;
end;

function TStToHTML.Get_CommentMarkers: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FCommentMarkers;
end;

function TStToHTML.Get_EmbeddedHTML: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FEmbeddedHTML;
end;

function TStToHTML.Get_FixedLineLength: Integer;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FSourceToHTML.InFixedLineLength;
end;

function TStToHTML.Get_LineTermChar: WideString;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FSourceToHTML.InLineTermChar;
end;

function TStToHTML.Get_LineTerminator: TStLineTerminator;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := TStLineTerminator(FSourceToHTML.InLineTerminator);
end;

function TStToHTML.Get_PageFooter: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FPageFooter;
end;

function TStToHTML.Get_PageHeader: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FPageHeader;
end;

function TStToHTML.Get_Stream: OleVariant;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := StStreamToOleVariant(FSourceToHTML.OutputStream);
end;

function TStToHTML.Get_StringMarkers: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FStringMarkers;
end;

function TStToHTML.Get_WordDelimeters: WideString;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FSourceToHTML.WordDelimiters;
end;

{ ********** TStSourceToHTML Properties *** (Set) **************************************** }
procedure TStToHTML.Set_CaseSensitve(Value: WordBool);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.CaseSensitive := Value;
end;

procedure TStToHTML.Set_CommentMarkers(const Value: IStStringList);
var
  MS : TStream;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  MS := nil;
  try
    MS := StOleVariantToStream(Value.Stream, True);
    FSourceToHTML.CommentMarkers.LoadFromStream(MS);
  finally
    MS.Free;
  end;
end;

procedure TStToHTML.Set_EmbeddedHTML(const Value: IStStringList);
var
  MS : TStream;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  MS := nil;
  try
    MS := StOleVariantToStream(Value.Stream, True);
    FSourceToHTML.EmbeddedHTML.LoadFromStream(MS);
  finally
    MS.Free;
  end;
end;

procedure TStToHTML.Set_FixedLineLength(Value: Integer);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.InFixedLineLength := Value;
end;

function TStToHTML.Get_Keywords: IStStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FKeywords;
end;

procedure TStToHTML.Set_Keywords(const Value: IStStringList);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FKeywords := Value;
end;

procedure TStToHTML.Set_LineTermChar(const Value: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.InLineTermChar := Char(Value[1]);
end;

procedure TStToHTML.Set_LineTerminator(Value: TStLineTerminator);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.InLineTerminator := StStrms.TStLineTerminator(Value);
end;

procedure TStToHTML.Set_PageFooter(const Value: IStStringList);
var
  MS : TStream;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  MS := nil;
  try
    MS := StOleVariantToStream(Value.Stream, True);
    FSourceToHTML.PageFooter.LoadFromStream(MS);
  finally
    MS.Free;
  end;
end;

procedure TStToHTML.Set_PageHeader(const Value: IStStringList);
var
  MS : TStream;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  MS := nil;
  try
    MS := StOleVariantToStream(Value.Stream, True);
    FSourceToHTML.PageHeader.LoadFromStream(MS);
  finally
    MS.Free;
  end;
end;

procedure TStToHTML.Set_Stream(Value: OleVariant);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.InputStream.CopyFrom(StOleVariantToStream(Value, True), 0);
  FSourceToHTML.InputStream.Position := 0;
end;

procedure TStToHTML.Set_StringMarkers(const Value: IStStringList);
var
  MS : TStream;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  MS := nil;
  try
    MS := StOleVariantToStream(Value.Stream, True);
    FSourceToHTML.StringMarkers.LoadFromStream(MS);
  finally
    MS.Free;
  end;
end;

procedure TStToHTML.Set_WordDelimeters(const Value: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.WordDelimiters := Value;
end;

{ ********** TStSourceToHTML Methods ***************************************************** }
procedure TStToHTML.Clear;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  TMemoryStream(FSourceToHTML.InputStream).Clear;
end;

procedure TStToHTML.GenerateHTML;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FSourceToHTML.GenerateHTML;
end;

procedure TStToHTML.LoadFromFile(const FileName: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  TMemoryStream(FSourceToHTML.InputStream).LoadFromFile(FileName);
end;

procedure TStToHTML.SaveToFile(const FileName: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  TMemoryStream(FSourceToHTML.OutputStream).SaveToFile(FileName);
end;

function TStToHTML.License(const Key: WideString): WordBool;
begin
  {$IFDEF LICENSE}
  Result := COMIsValidKey(Key);

  { License the objects used in this class }
  FKeywords.License(Key);
  FCommentMarkers.License(Key);
  FEmbeddedHTML.License(Key);
  FPageFooter.License(Key);
  FPageHeader.License(Key);
  FStringMarkers.License(Key);

  {$ELSE}
  Result := True;
  {$ENDIF}
  FIsLicensed := Result;
end;

initialization
  TAutoObjectFactory.Create(ComServer, TStToHTML, Class_StToHTML, ciMultiInstance, tmBoth);
end.
1	torben	2671	(* *** BEGIN LICENSE BLOCK ***
2			* Version: MPL 1.1
3			*
4			* The contents of this file are subject to the Mozilla Public License Version
5			* 1.1 (the "License"); you may not use this file except in compliance with
6			* the License. You may obtain a copy of the License at
7			* http://www.mozilla.org/MPL/
8			*
9			* Software distributed under the License is distributed on an "AS IS" basis,
10			* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11			* for the specific language governing rights and limitations under the
12			* License.
13			*
14			* The Original Code is TurboPower SysTools
15			*
16			* The Initial Developer of the Original Code is
17			* TurboPower Software
18			*
19			* Portions created by the Initial Developer are Copyright (C) 1996-2002
20			* the Initial Developer. All Rights Reserved.
21			*
22			* Contributor(s):
23			*
24			* *** END LICENSE BLOCK *** *)
25
26			{*********************************************************}
27			{* _STTOHTML.PAS 3.00 *}
28			{*********************************************************}
29
30			{$I STDEFINE.INC}
31			{$I STCOMDEF.INC}
32			unit _StToHTML;
33
34			interface
35
36			uses
37			ComObj, ActiveX, AxCtrls, Classes, StStrms, StToHTML, SysTools_TLB, _StUtil, StdVcl;
38
39			type
40			TStToHTML = class(TAutoObject, IConnectionPointContainer, IStToHTML)
41			private { Private declarations }
42			FConnectionPoints: TConnectionPoints;
43			FConnectionPoint: TConnectionPoint;
44			FSinkList: TList;
45			FEvents: IStToHTMLEvents;
46
47			FSourceToHTML : StToHTML.TStStreamToHTML;
48			FKeywords : IStStringList;
49			FCommentMarkers: IStStringList;
50			FEmbeddedHTML : IStStringList;
51			FPageFooter : IStStringList;
52			FPageHeader : IStStringList;
53			FStringMarkers : IStStringList;
54
55			FIsLicensed : Boolean;
56
57			procedure _OnProgress(Sender : TObject; Percent : Word);
58			public { Public declarations }
59			procedure Initialize; override;
60			destructor Destroy; override;
61			protected {Protected declarations }
62			{ IConnectionPointContainer }
63			property ConnectionPoints: TConnectionPoints read FConnectionPoints
64			implements IConnectionPointContainer;
65			procedure EventSinkChanged(const EventSink: IUnknown); override;
66
67			{ IStToHTML properties (GET) }
68			function Get_CaseSensitve: WordBool; safecall;
69			function Get_CommentMarkers: IStStringList; safecall;
70			function Get_EmbeddedHTML: IStStringList; safecall;
71			function Get_FixedLineLength: Integer; safecall;
72			function Get_Keywords: IStStringList; safecall;
73			function Get_LineTermChar: WideString; safecall;
74			function Get_LineTerminator: TStLineTerminator; safecall;
75			function Get_PageFooter: IStStringList; safecall;
76			function Get_PageHeader: IStStringList; safecall;
77			function Get_Stream: OleVariant; safecall;
78			function Get_StringMarkers: IStStringList; safecall;
79			function Get_WordDelimeters: WideString; safecall;
80
81			{ IStToHTML properties (SET) }
82			procedure Set_CaseSensitve(Value: WordBool); safecall;
83			procedure Set_CommentMarkers(const Value: IStStringList); safecall;
84			procedure Set_EmbeddedHTML(const Value: IStStringList); safecall;
85			procedure Set_FixedLineLength(Value: Integer); safecall;
86			procedure Set_Keywords(const Value: IStStringList); safecall;
87			procedure Set_LineTermChar(const Value: WideString); safecall;
88			procedure Set_LineTerminator(Value: TStLineTerminator); safecall;
89			procedure Set_PageFooter(const Value: IStStringList); safecall;
90			procedure Set_PageHeader(const Value: IStStringList); safecall;
91			procedure Set_Stream(Value: OleVariant); safecall;
92			procedure Set_StringMarkers(const Value: IStStringList); safecall;
93			procedure Set_WordDelimeters(const Value: WideString); safecall;
94
95			{ IStToHTML methods }
96			procedure Clear; safecall;
97			procedure GenerateHTML; safecall;
98			procedure LoadFromFile(const FileName: WideString); safecall;
99			procedure SaveToFile(const FileName: WideString); safecall;
100			function License(const Key: WideString): WordBool; safecall;
101			end;
102
103			implementation
104
105			uses ComServ {$IFDEF LICENSE}, StComLic {$ENDIF};
106
107			{ ******** TStSourceToHTML Interface - IConnectionPointContainer Methods ************* }
108			procedure TStToHTML.EventSinkChanged(const EventSink: IUnknown);
109			begin
110			FEvents := EventSink as IStToHTMLEvents;
111			if FConnectionPoint <> nil then
112			FSinkList := FConnectionPoint.SinkList;
113			end;
114
115			{ ******** TStSourceToHTML Interface ************************************************* }
116			procedure TStToHTML.Initialize;
117			begin
118			inherited Initialize;
119			FConnectionPoints := TConnectionPoints.Create(Self);
120			if AutoFactory.EventTypeInfo <> nil then
121			FConnectionPoint := FConnectionPoints.CreateConnectionPoint(
122			AutoFactory.EventIID, ckSingle, EventConnect)
123			else FConnectionPoint := nil;
124
125			{$IFDEF LICENSE}
126			FIsLicensed := False;
127			{$ELSE}
128			FIsLicensed := True;
129			{$ENDIF}
130
131			FSourceToHTML := StToHTML.TStStreamToHTML.Create;
132			FSourceToHTML.InputStream := Classes.TMemoryStream.Create;
133			FSourceToHTML.OutputStream := Classes.TMemoryStream.Create;
134
135			FKeywords := TStStringList.Create(FSourceToHTML.Keywords);
136			FCommentMarkers := TStStringList.Create(FSourceToHTML.CommentMarkers);
137			FEmbeddedHTML := TStStringList.Create(FSourceToHTML.EmbeddedHTML);
138			FPageFooter := TStStringList.Create(FSourceToHTML.PageFooter);
139			FPageHeader := TStStringList.Create(FSourceToHTML.PageHeader);
140			FStringMarkers := TStStringList.Create(FSourceToHTML.StringMarkers);
141
142			FSourceToHTML.OnProgress := _OnProgress;
143			end;
144
145			destructor TStToHTML.Destroy;
146			begin
147			if Assigned(FSourceToHTML.InputStream) then
148			FSourceToHTML.InputStream.Free;
149
150			if Assigned(FSourceToHTML.OutputStream) then
151			FSourceToHTML.OutputStream.Free;
152
153			FKeywords := nil;
154			FCommentMarkers := nil;
155			FEmbeddedHTML := nil;
156			FPageFooter := nil;
157			FPageHeader := nil;
158			FStringMarkers := nil;
159
160			FSourceToHTML.Free;
161
162			inherited Destroy;
163			end;
164
165			{ ******** TStSourceToHTML Events **************************************************** }
166			procedure TStToHTML._OnProgress(Sender : TObject; Percent : Word);
167			begin
168			if Assigned(FEvents) then
169			FEvents.OnProgress(Percent);
170			end;
171
172			{ ******** TStSourceToHTML Properties * (Get) **************************************** }
173			function TStToHTML.Get_CaseSensitve: WordBool;
174			begin
175			{$IFDEF LICENSE}
176			if (not FIsLicensed) or (not COMHasBeenLicensed) then
177			OleError(CLASS_E_NOTLICENSED);
178			{$ENDIF}
179			Result := FSourceToHTML.CaseSensitive;
180			end;
181
182			function TStToHTML.Get_CommentMarkers: IStStringList;
183			begin
184			{$IFDEF LICENSE}
185			if (not FIsLicensed) or (not COMHasBeenLicensed) then
186			OleError(CLASS_E_NOTLICENSED);
187			{$ENDIF}
188			Result := FCommentMarkers;
189			end;
190
191			function TStToHTML.Get_EmbeddedHTML: IStStringList;
192			begin
193			{$IFDEF LICENSE}
194			if (not FIsLicensed) or (not COMHasBeenLicensed) then
195			OleError(CLASS_E_NOTLICENSED);
196			{$ENDIF}
197			Result := FEmbeddedHTML;
198			end;
199
200			function TStToHTML.Get_FixedLineLength: Integer;
201			begin
202			{$IFDEF LICENSE}
203			if (not FIsLicensed) or (not COMHasBeenLicensed) then
204			OleError(CLASS_E_NOTLICENSED);
205			{$ENDIF}
206			Result := FSourceToHTML.InFixedLineLength;
207			end;
208
209			function TStToHTML.Get_LineTermChar: WideString;
210			begin
211			{$IFDEF LICENSE}
212			if (not FIsLicensed) or (not COMHasBeenLicensed) then
213			OleError(CLASS_E_NOTLICENSED);
214			{$ENDIF}
215			Result := FSourceToHTML.InLineTermChar;
216			end;
217
218			function TStToHTML.Get_LineTerminator: TStLineTerminator;
219			begin
220			{$IFDEF LICENSE}
221			if (not FIsLicensed) or (not COMHasBeenLicensed) then
222			OleError(CLASS_E_NOTLICENSED);
223			{$ENDIF}
224			Result := TStLineTerminator(FSourceToHTML.InLineTerminator);
225			end;
226
227			function TStToHTML.Get_PageFooter: IStStringList;
228			begin
229			{$IFDEF LICENSE}
230			if (not FIsLicensed) or (not COMHasBeenLicensed) then
231			OleError(CLASS_E_NOTLICENSED);
232			{$ENDIF}
233			Result := FPageFooter;
234			end;
235
236			function TStToHTML.Get_PageHeader: IStStringList;
237			begin
238			{$IFDEF LICENSE}
239			if (not FIsLicensed) or (not COMHasBeenLicensed) then
240			OleError(CLASS_E_NOTLICENSED);
241			{$ENDIF}
242			Result := FPageHeader;
243			end;
244
245			function TStToHTML.Get_Stream: OleVariant;
246			begin
247			{$IFDEF LICENSE}
248			if (not FIsLicensed) or (not COMHasBeenLicensed) then
249			OleError(CLASS_E_NOTLICENSED);
250			{$ENDIF}
251			Result := StStreamToOleVariant(FSourceToHTML.OutputStream);
252			end;
253
254			function TStToHTML.Get_StringMarkers: IStStringList;
255			begin
256			{$IFDEF LICENSE}
257			if (not FIsLicensed) or (not COMHasBeenLicensed) then
258			OleError(CLASS_E_NOTLICENSED);
259			{$ENDIF}
260			Result := FStringMarkers;
261			end;
262
263			function TStToHTML.Get_WordDelimeters: WideString;
264			begin
265			{$IFDEF LICENSE}
266			if (not FIsLicensed) or (not COMHasBeenLicensed) then
267			OleError(CLASS_E_NOTLICENSED);
268			{$ENDIF}
269			Result := FSourceToHTML.WordDelimiters;
270			end;
271
272			{ ******** TStSourceToHTML Properties * (Set) **************************************** }
273			procedure TStToHTML.Set_CaseSensitve(Value: WordBool);
274			begin
275			{$IFDEF LICENSE}
276			if (not FIsLicensed) or (not COMHasBeenLicensed) then
277			OleError(CLASS_E_NOTLICENSED);
278			{$ENDIF}
279			FSourceToHTML.CaseSensitive := Value;
280			end;
281
282			procedure TStToHTML.Set_CommentMarkers(const Value: IStStringList);
283			var
284			MS : TStream;
285			begin
286			{$IFDEF LICENSE}
287			if (not FIsLicensed) or (not COMHasBeenLicensed) then
288			OleError(CLASS_E_NOTLICENSED);
289			{$ENDIF}
290			MS := nil;
291			try
292			MS := StOleVariantToStream(Value.Stream, True);
293			FSourceToHTML.CommentMarkers.LoadFromStream(MS);
294			finally
295			MS.Free;
296			end;
297			end;
298
299			procedure TStToHTML.Set_EmbeddedHTML(const Value: IStStringList);
300			var
301			MS : TStream;
302			begin
303			{$IFDEF LICENSE}
304			if (not FIsLicensed) or (not COMHasBeenLicensed) then
305			OleError(CLASS_E_NOTLICENSED);
306			{$ENDIF}
307			MS := nil;
308			try
309			MS := StOleVariantToStream(Value.Stream, True);
310			FSourceToHTML.EmbeddedHTML.LoadFromStream(MS);
311			finally
312			MS.Free;
313			end;
314			end;
315
316			procedure TStToHTML.Set_FixedLineLength(Value: Integer);
317			begin
318			{$IFDEF LICENSE}
319			if (not FIsLicensed) or (not COMHasBeenLicensed) then
320			OleError(CLASS_E_NOTLICENSED);
321			{$ENDIF}
322			FSourceToHTML.InFixedLineLength := Value;
323			end;
324
325			function TStToHTML.Get_Keywords: IStStringList;
326			begin
327			{$IFDEF LICENSE}
328			if (not FIsLicensed) or (not COMHasBeenLicensed) then
329			OleError(CLASS_E_NOTLICENSED);
330			{$ENDIF}
331			Result := FKeywords;
332			end;
333
334			procedure TStToHTML.Set_Keywords(const Value: IStStringList);
335			begin
336			{$IFDEF LICENSE}
337			if (not FIsLicensed) or (not COMHasBeenLicensed) then
338			OleError(CLASS_E_NOTLICENSED);
339			{$ENDIF}
340			FKeywords := Value;
341			end;
342
343			procedure TStToHTML.Set_LineTermChar(const Value: WideString);
344			begin
345			{$IFDEF LICENSE}
346			if (not FIsLicensed) or (not COMHasBeenLicensed) then
347			OleError(CLASS_E_NOTLICENSED);
348			{$ENDIF}
349			FSourceToHTML.InLineTermChar := Char(Value[1]);
350			end;
351
352			procedure TStToHTML.Set_LineTerminator(Value: TStLineTerminator);
353			begin
354			{$IFDEF LICENSE}
355			if (not FIsLicensed) or (not COMHasBeenLicensed) then
356			OleError(CLASS_E_NOTLICENSED);
357			{$ENDIF}
358			FSourceToHTML.InLineTerminator := StStrms.TStLineTerminator(Value);
359			end;
360
361			procedure TStToHTML.Set_PageFooter(const Value: IStStringList);
362			var
363			MS : TStream;
364			begin
365			{$IFDEF LICENSE}
366			if (not FIsLicensed) or (not COMHasBeenLicensed) then
367			OleError(CLASS_E_NOTLICENSED);
368			{$ENDIF}
369			MS := nil;
370			try
371			MS := StOleVariantToStream(Value.Stream, True);
372			FSourceToHTML.PageFooter.LoadFromStream(MS);
373			finally
374			MS.Free;
375			end;
376			end;
377
378			procedure TStToHTML.Set_PageHeader(const Value: IStStringList);
379			var
380			MS : TStream;
381			begin
382			{$IFDEF LICENSE}
383			if (not FIsLicensed) or (not COMHasBeenLicensed) then
384			OleError(CLASS_E_NOTLICENSED);
385			{$ENDIF}
386			MS := nil;
387			try
388			MS := StOleVariantToStream(Value.Stream, True);
389			FSourceToHTML.PageHeader.LoadFromStream(MS);
390			finally
391			MS.Free;
392			end;
393			end;
394
395			procedure TStToHTML.Set_Stream(Value: OleVariant);
396			begin
397			{$IFDEF LICENSE}
398			if (not FIsLicensed) or (not COMHasBeenLicensed) then
399			OleError(CLASS_E_NOTLICENSED);
400			{$ENDIF}
401			FSourceToHTML.InputStream.CopyFrom(StOleVariantToStream(Value, True), 0);
402			FSourceToHTML.InputStream.Position := 0;
403			end;
404
405			procedure TStToHTML.Set_StringMarkers(const Value: IStStringList);
406			var
407			MS : TStream;
408			begin
409			{$IFDEF LICENSE}
410			if (not FIsLicensed) or (not COMHasBeenLicensed) then
411			OleError(CLASS_E_NOTLICENSED);
412			{$ENDIF}
413			MS := nil;
414			try
415			MS := StOleVariantToStream(Value.Stream, True);
416			FSourceToHTML.StringMarkers.LoadFromStream(MS);
417			finally
418			MS.Free;
419			end;
420			end;
421
422			procedure TStToHTML.Set_WordDelimeters(const Value: WideString);
423			begin
424			{$IFDEF LICENSE}
425			if (not FIsLicensed) or (not COMHasBeenLicensed) then
426			OleError(CLASS_E_NOTLICENSED);
427			{$ENDIF}
428			FSourceToHTML.WordDelimiters := Value;
429			end;
430
431			{ ******** TStSourceToHTML Methods *************************************************** }
432			procedure TStToHTML.Clear;
433			begin
434			{$IFDEF LICENSE}
435			if (not FIsLicensed) or (not COMHasBeenLicensed) then
436			OleError(CLASS_E_NOTLICENSED);
437			{$ENDIF}
438			TMemoryStream(FSourceToHTML.InputStream).Clear;
439			end;
440
441			procedure TStToHTML.GenerateHTML;
442			begin
443			{$IFDEF LICENSE}
444			if (not FIsLicensed) or (not COMHasBeenLicensed) then
445			OleError(CLASS_E_NOTLICENSED);
446			{$ENDIF}
447			FSourceToHTML.GenerateHTML;
448			end;
449
450			procedure TStToHTML.LoadFromFile(const FileName: WideString);
451			begin
452			{$IFDEF LICENSE}
453			if (not FIsLicensed) or (not COMHasBeenLicensed) then
454			OleError(CLASS_E_NOTLICENSED);
455			{$ENDIF}
456			TMemoryStream(FSourceToHTML.InputStream).LoadFromFile(FileName);
457			end;
458
459			procedure TStToHTML.SaveToFile(const FileName: WideString);
460			begin
461			{$IFDEF LICENSE}
462			if (not FIsLicensed) or (not COMHasBeenLicensed) then
463			OleError(CLASS_E_NOTLICENSED);
464			{$ENDIF}
465			TMemoryStream(FSourceToHTML.OutputStream).SaveToFile(FileName);
466			end;
467
468			function TStToHTML.License(const Key: WideString): WordBool;
469			begin
470			{$IFDEF LICENSE}
471			Result := COMIsValidKey(Key);
472
473			{ License the objects used in this class }
474			FKeywords.License(Key);
475			FCommentMarkers.License(Key);
476			FEmbeddedHTML.License(Key);
477			FPageFooter.License(Key);
478			FPageHeader.License(Key);
479			FStringMarkers.License(Key);
480
481			{$ELSE}
482			Result := True;
483			{$ENDIF}
484			FIsLicensed := Result;
485			end;
486
487			initialization
488			TAutoObjectFactory.Create(ComServer, TStToHTML, Class_StToHTML, ciMultiInstance, tmBoth);
489			end.