rvfmisc.pas

richview1.7 full.source

unit RVFMisc;

interface
{$I RV_Defs.inc}
uses Classes, SysUtils, Graphics, Controls,
     RVStyle, RVUni;

procedure RVFWrite(Stream: TStream; const s: String);
procedure RVFWriteLine(Stream: TStream; s: String);
procedure RVFWriteLineX(Stream: TStream; const s: String; Unicode: Boolean);
function RVFStream2TextString(Stream: TMemoryStream): String;
function RVFTextString2Stream(const str: String; Stream: TMemoryStream): Boolean;

function RVEncodeString(const str: String): String;
function RVDecodeString(const str: String): String;

{$IFDEF RICHVIEWCBDEF3}
function RVEncodeWideString(const str: WideString): String;
function RVDecodeWideString(const str: String): WideString;
{$ENDIF}

function RVFLoadPicture(const s: String; gr: TGraphic): Boolean;
function RVFSavePicture(gr: TGraphic): String;
procedure RVFLoadPictureBinary(const Data: String; gr: TGraphic);
procedure RVFSavePictureBinary(Stream: TStream; gr: TGraphic);
function RVFLoadControl(const s: String; var ctrl: TComponent;
                        const ClassName: String;
                        ParentControl: TWinControl): Boolean;
function RVFSaveControl(ctrl: TComponent): String;
procedure RVFLoadControlBinary(const Data: String; var ctrl: TComponent;
                               const ClassName: String;
                               ParentControl: TWinControl);
procedure RVFSaveControlBinary(Stream: TStream; ctrl: TComponent);

function RVFReadString(var P: PChar; var s: String): Boolean;
function RVFReadInteger(var P: PChar; var V: Integer): Boolean;
{$IFDEF RICHVIEWCBDEF3}
function RVFReadText(var P: PChar): String;
{$ENDIF}
function RVFReadTag(var P: PChar; TagsArePChars: Boolean; var Tag: Integer): Boolean
;
function RVFReadParaStyle(RVStyle: TRVStyle; var P: PChar; var V: Integer): Boolean;
function RVFReadTextStyle(RVStyle: TRVStyle; var P: PChar; var V: Integer): Boolean;

function RVFSaveTag(TagsArePChars:Boolean; Tag: Integer): String;
function RVFSaveText(RVStyle:TRVStyle; UseStyleNames: Boolean; TextIdx: Integer): String;
function RVFSavePara(RVStyle:TRVStyle; UseStyleNames: Boolean; TextIdx: Integer): String;
function RVFItemSavePara(ParaNo: Integer; RVData: TPersistent;
                         ForceSameAsPrev: Boolean): String;

implementation
uses RVStr, RVFuncs, CRVData;
const
  crlf = #13#10;
{-----------------------------------------------------------------------}
procedure RVFWrite(Stream: TStream; const s: String);
begin
  Stream.WriteBuffer(PChar(s)^, Length(s));
end;
{-----------------------------------------------------------------------}
procedure RVFWriteLine(Stream: TStream; s: String);
begin
  s := s+crlf;
  Stream.WriteBuffer(PChar(s)^, Length(s));
end;
{-----------------------------------------------------------------------}
procedure RVFWriteLineX(Stream: TStream; const s: String; Unicode: Boolean);
var sep: String;
begin
  Stream.WriteBuffer(PChar(s)^, Length(s));
  if Unicode then
    sep := String(Chr(Lo(UNI_ParagraphSeparator)))+Chr(Hi(UNI_ParagraphSeparator))
  else
    sep := crlf;
  Stream.WriteBuffer(PChar(sep)^, Length(sep));
end;
{-----------------------------------------------------------------------}
function RVFStream2TextString(Stream: TMemoryStream): String;
var i: Integer;
    hex: String;
begin
 SetLength(Result, Stream.Size*2);
 for i := 0 to Stream.Size-1 do begin
   hex := IntToHex(Ord(PChar(Stream.Memory)[i]),2);
   Result[i*2+1] := hex[1];
   Result[i*2+2] := hex[2];
 end;
end;
{-----------------------------------------------------------------------}
function RVEncodeString(const str: String): String;
var i: Integer;
    hex: String;
begin
 SetLength(Result, Length(str)*2);
 for i := 0 to Length(str)-1 do begin
   hex := IntToHex(Ord(str[i+1]),2);
   Result[i*2+1] := hex[1];
   Result[i*2+2] := hex[2];
 end;
end;
{-----------------------------------------------------------------------}
function RVFTextString2Stream(const str: String; Stream: TMemoryStream): Boolean;
var i,d1,d2, idx1, idx2: Integer;
    s: String;
begin
 Result := False;
 if (Length(str) mod 2)<>0 then exit;
 Stream.SetSize(Length(str) div 2);
 s := UpperCase(str);
 for i := 0 to (Length(s) div 2)-1 do begin
   idx1 := i*2+1;
   idx2 := i*2+2;
   if not (s[idx1] in ['0'..'9','A'..'F']) or
     not (s[idx2] in ['0'..'9','A'..'F']) then exit;
   if s[idx1] in ['0'..'9'] then
     d1 := Ord(s[idx1])-Ord('0')
   else
     d1 := Ord(s[idx1])-Ord('A')+10;
   if s[idx2] in ['0'..'9'] then
     d2 := Ord(s[idx2])-Ord('0')
   else
     d2 := Ord(s[idx2])-Ord('A')+10;
   PChar(Stream.Memory)[i] := Chr(d1*16+d2);
 end;
 Result := True;
end;
{-----------------------------------------------------------------------}
function RVDecodeString(const str: String): String;
var i,d1,d2, idx1, idx2: Integer;
    s: String;
begin
 Result := '';
 if (Length(str) mod 2)<>0 then exit;
 SetLength(Result, Length(str) div 2);
 s := UpperCase(str);
 for i := 0 to (Length(s) div 2)-1 do begin
   idx1 := i*2+1;
   idx2 := i*2+2;
   if not (s[idx1] in ['0'..'9','A'..'F']) or
     not (s[idx2] in ['0'..'9','A'..'F']) then exit;
   if s[idx1] in ['0'..'9'] then
     d1 := Ord(s[idx1])-Ord('0')
   else
     d1 := Ord(s[idx1])-Ord('A')+10;
   if s[idx2] in ['0'..'9'] then
     d2 := Ord(s[idx2])-Ord('0')
   else
     d2 := Ord(s[idx2])-Ord('A')+10;
   Result[i+1] := Chr(d1*16+d2);
 end;
end;
{-----------------------------------------------------------------------}
{$IFDEF RICHVIEWCBDEF3}
function RVEncodeWideString(const str: WideString): String;
var i: Integer;
    hex: String;
begin
 SetLength(Result, Length(str)*4);
 for i := 0 to Length(str)-1 do begin
   hex := IntToHex(Word(str[i+1]),4);
   Result[i*4+1] := hex[1];
   Result[i*4+2] := hex[2];
   Result[i*4+3] := hex[3];
   Result[i*4+4] := hex[4];
 end;
end;
{-----------------------------------------------------------------------}
function RVDecodeWideString(const str: String): WideString;
var i,d1,d2,d3,d4, idx1, idx2, idx3, idx4: Integer;
    s: String;
begin
 Result := '';
 if (Length(str) mod 4)<>0 then exit;
 SetLength(Result, Length(str) div 4);
 s := UpperCase(str);
 for i := 0 to (Length(s) div 4)-1 do begin
   idx1 := i*4+1;
   idx2 := idx1+1;
   idx3 := idx2+1;
   idx4 := idx3+1;
   if not (s[idx1] in ['0'..'9','A'..'F']) or
     not (s[idx2] in ['0'..'9','A'..'F']) or
     not (s[idx3] in ['0'..'9','A'..'F']) or
     not (s[idx4] in ['0'..'9','A'..'F']) then exit;
   if s[idx1] in ['0'..'9'] then
     d1 := Ord(s[idx1])-Ord('0')
   else
     d1 := Ord(s[idx1])-Ord('A')+10;
   if s[idx2] in ['0'..'9'] then
     d2 := Ord(s[idx2])-Ord('0')
   else
     d2 := Ord(s[idx2])-Ord('A')+10;
   if s[idx3] in ['0'..'9'] then
     d3 := Ord(s[idx3])-Ord('0')
   else
     d3 := Ord(s[idx3])-Ord('A')+10;
   if s[idx4] in ['0'..'9'] then
     d4 := Ord(s[idx4])-Ord('0')
   else
     d4 := Ord(s[idx4])-Ord('A')+10;
   Result[i+1] := WideChar(((d1*16+d2)*16+d3)*16+d4);
 end;
end;
{$ENDIF}
{-----------------------------------------------------------------------}
function RVFLoadPicture(const s: String; gr: TGraphic): Boolean;
var Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    Result := RVFTextString2Stream(s,Stream);
    Stream.Position := 0;
    gr.LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;
{-----------------------------------------------------------------------}
function RVFSavePicture(gr: TGraphic): String;
var Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    gr.SaveToStream(Stream);
    Result := RVFStream2TextString(Stream);
  finally
    Stream.Free;
  end;
end;
{-----------------------------------------------------------------------}
procedure RVFLoadPictureBinary(const Data: String; gr: TGraphic);
var Stream: TMemoryStream;
begin
  Stream  := TMemoryStream.Create;
  try
    Stream.SetSize(Length(Data));
    Move(PChar(Data)^, Stream.Memory^, Length(Data));
    Stream.Position := 0;
    gr.LoadFromStream(Stream);
  finally
    Stream.Free;
  end;