{-----------------------------------------------------------------------------
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/MPL-1.1.html

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is: JvDataEmbedded.PAS, released on 2001-02-28.

The Initial Developer of the Original Code is Sébastien Buysse [sbuysse att buypin dott com]
Portions created by Sébastien Buysse are Copyright (C) 2001 Sébastien Buysse ,dejoy.
All Rights Reserved.

Contributor(s): Michael Beck [mbeck att bigfoot dott com].
 --Added TJvComponentEmbedded and TJvPersistentEmbedded from dejoy 2004-7-30.
 /* override DefineUnPublishedProperties to define property,in DefineUnPublishedProperties,
  if define general property to use DoDefineProperty,else if Define Binary Property to use DoDefineBinaryProperty.
  override ReadUnPublished and WriteUnPublished to read or write property,in  ReadUnPublished or WriteUnPublished,
   you can use DefinePropertyIs to detect which propety is  processing.
  if you have many UnPublished Properties to process,
  You did't need write a lot of WriteXXX or ReadXXX procedure to process property like old way,
  just to override DefineUnPublishedProperties and ReadUnPublished and WriteUnPublished only ~_~.
  */

You may retrieve the latest version of this file at the Project JEDI's JVCL home page,
located at http://jvcl.sourceforge.net

Known Issues:
-----------------------------------------------------------------------------}
// $Id: JvDataEmbedded.pas,v 1.10 2004/07/20 14:31:05 marquardt Exp $

unit JvDataEmbedded;

{$I jvcl.inc}

interface

uses
  SysUtils, Classes,
  JVCLVer;

type

  TJvPersistentEmbedded = class(TInterfacedPersistent)
  private
    FFiler : TFiler;
    FFilerTag:String;

  protected
    procedure DefineProperties(Filer: TFiler); override;

    procedure DefineUnPublishedProperties(aFiler: TFiler);virtual;
    function  DefinePropertyIs(aName:string):boolean;dynamic;
    procedure DoDefineProperty(aName:string;aHasData:boolean);dynamic;
    procedure DoDefineBinaryProperty(aName:string;aHasData:boolean);dynamic;
    procedure ReadUnPublished(Reader: TReader);overload;dynamic;
    procedure WriteUnPublished(Writer: TWriter); overload;dynamic;
    procedure ReadUnPublished(aStream: TStream);overload;dynamic;
    procedure WriteUnPublished(aStream: TStream); overload;dynamic;
  public
    procedure SavetoStream(Stream: TStream);virtual;
    procedure LoadFromStream(Stream: TStream);virtual;

  published

  end;



  TJvComponentEmbedded = class(TComponent)
  private
    FFiler : TFiler;
    FFilerTag:String;

  protected
    procedure DefineProperties(Filer: TFiler); override;

    procedure DefineUnPublishedProperties(aFiler: TFiler);virtual;
    function  DefinePropertyIs(aName:string):boolean;dynamic;
    procedure DoDefineProperty(aName:string;aHasData:boolean);dynamic;
    procedure DoDefineBinaryProperty(aName:string;aHasData:boolean);dynamic;
    procedure ReadUnPublished(Reader: TReader);overload;dynamic;
    procedure WriteUnPublished(Writer: TWriter); overload;dynamic;
    procedure ReadUnPublished(aStream: TStream);overload;dynamic;
    procedure WriteUnPublished(aStream: TStream); overload;dynamic;
  public
    procedure SavetoStream(Stream: TStream);virtual;
    procedure LoadFromStream(Stream: TStream);virtual;

  published

  end;


  TJvDataEmbedded = class(TJvComponentEmbedded)
  private
    FAboutJVCL: TJVCLAboutInfo; // (ahuser) removed JvComponent dependency for easy CLX usage
    FStream: TMemoryStream;
    function GetSize: Integer;
    function GetStream: TStream;
    procedure SetStream(const Value: TStream);
    procedure SetSize(const Value: Integer);
  protected
    procedure DefineUnPublishedProperties(aFiler: TFiler);override;
    procedure ReadUnPublished(aStream: TStream);override;
    procedure WriteUnPublished(aStream: TStream); override;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure DataSaveToFile(FileName: TFileName);
    procedure DataSaveToStream(Stream: TStream);
    property Size: Integer read GetSize write SetSize;
    // (rom) These properties were published. Silly.
    property Data: TStream read GetStream write SetStream;
  published
    property AboutJVCL: TJVCLAboutInfo read FAboutJVCL write FAboutJVCL stored False;
  end;

implementation

constructor TJvDataEmbedded.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FStream := TMemoryStream.Create;
end;

destructor TJvDataEmbedded.Destroy;
begin
  FStream.Free;
  inherited Destroy;
end;

function TJvDataEmbedded.GetSize: Integer;
begin
  Result := FStream.Size;
end;

function TJvDataEmbedded.GetStream: TStream;
begin
  Result := FStream;
  Result.Position := 0;
end;

procedure TJvDataEmbedded.SetStream(const Value: TStream);
begin
  FStream.Clear;
  if Value <> nil then
    FStream.CopyFrom(Value, Value.Size - Value.Position);
end;

procedure TJvDataEmbedded.DataSaveToFile(FileName: TFileName);
begin
  FStream.SaveToFile(FileName);
end;

procedure TJvDataEmbedded.DataSaveToStream(Stream: TStream);
begin
  Stream.CopyFrom(FStream, 0);
end;

procedure TJvDataEmbedded.SetSize(const Value: Integer);
begin
  FStream.SetSize(Value);
end;

{ TJvComponentEmbedded }

procedure TJvComponentEmbedded.DefineProperties(Filer: TFiler);
begin
  FFiler :=Filer;
  inherited DefineProperties(Filer);
  DefineUnPublishedProperties(Filer);
end;

function TJvComponentEmbedded.DefinePropertyIs(aName: string): boolean;
begin
  Result := AnsiSameText(FFilerTag,aName);
end;

procedure TJvComponentEmbedded.DefineUnPublishedProperties(aFiler: TFiler);
begin

end;

procedure TJvComponentEmbedded.DoDefineBinaryProperty(aName: string;
  aHasData: boolean);
begin
  FFilerTag:=aName;
  if  Assigned(FFiler) and (aName<>'')  then
    FFiler.DefineBinaryProperty(aName,ReadUnPublished,WriteUnPublished,aHasData);
end;

procedure TJvComponentEmbedded.DoDefineProperty(aName: string;
  aHasData: boolean);
begin
  FFilerTag:=aName;
  if  Assigned(FFiler) and (aName<>'') then
    FFiler.DefineProperty(aName,ReadUnPublished,WriteUnPublished,aHasData);
end;

procedure TJvComponentEmbedded.ReadUnPublished(Reader: TReader);
begin

end;

procedure TJvComponentEmbedded.LoadFromStream(Stream: TStream);
begin
  if (Stream=nil) or (Stream.Size=0) then Exit;
  Stream.ReadComponent(Self);
end;

procedure TJvComponentEmbedded.ReadUnPublished(aStream: TStream);
begin

end;

procedure TJvComponentEmbedded.WriteUnPublished(Writer: TWriter);
begin

end;

procedure TJvComponentEmbedded.SavetoStream(Stream: TStream);
begin
    Stream.WriteComponent(Self) ;
end;

procedure TJvComponentEmbedded.WriteUnPublished(aStream: TStream);
begin

end;

type

  TPersistentWrapper = class(TComponent)
  private
    FPersistent: TPersistent;
  published
     property Persistent :TPersistent read FPersistent write FPersistent;
  end;


{ TJvPersistentEmbedded }

procedure TJvPersistentEmbedded.DefineProperties(Filer: TFiler);
begin
  FFiler :=Filer;
  inherited DefineProperties(Filer);
  DefineUnPublishedProperties(Filer);
end;

function TJvPersistentEmbedded.DefinePropertyIs(aName: string): boolean;
begin
  Result := AnsiSameText(FFilerTag,aName);
end;

procedure TJvPersistentEmbedded.DefineUnPublishedProperties(
  aFiler: TFiler);
begin

end;

procedure TJvPersistentEmbedded.DoDefineBinaryProperty(aName: string;
  aHasData: boolean);
begin
  FFilerTag:=aName;
  if  Assigned(FFiler) and (aName<>'')  then
    FFiler.DefineBinaryProperty(aName,ReadUnPublished,WriteUnPublished,aHasData);
end;

procedure TJvPersistentEmbedded.DoDefineProperty(aName: string;
  aHasData: boolean);
begin
  FFilerTag:=aName;
  if  Assigned(FFiler) and (aName<>'') then
    FFiler.DefineProperty(aName,ReadUnPublished,WriteUnPublished,aHasData);
end;

procedure TJvPersistentEmbedded.LoadFromStream(Stream: TStream);
var
  m:TPersistentWrapper;
begin
  if (Stream=nil) or (Stream.Size=0) then Exit;
  m := TPersistentWrapper.Create(nil);
  try
    m.FPersistent := Self;
    Stream.ReadComponent(m);
    m.FPersistent := nil;
  finally
    m.Free;
  end;
  
end;

procedure TJvPersistentEmbedded.ReadUnPublished(aStream: TStream);
begin

end;

procedure TJvPersistentEmbedded.ReadUnPublished(Reader: TReader);
begin

end;

procedure TJvPersistentEmbedded.SavetoStream(Stream: TStream);
var
  m:TPersistentWrapper;
begin
  m := TPersistentWrapper.Create(nil);
  try
    m.FPersistent := Self;
    Stream.WriteComponent(m) ;
  finally
    m.Free;
  end;

end;

procedure TJvPersistentEmbedded.WriteUnPublished(Writer: TWriter);
begin

end;

procedure TJvPersistentEmbedded.WriteUnPublished(aStream: TStream);
begin

end;


procedure TJvDataEmbedded.DefineUnPublishedProperties(aFiler: TFiler);
begin
  inherited DefineUnPublishedProperties(aFiler);
  DoDefineBinaryProperty('EmbeddedData', FStream.Size > 0);

end;

procedure TJvDataEmbedded.ReadUnPublished(aStream: TStream);
var
  I: Integer;
begin
  if  DefinePropertyIs('EmbeddedData') then
  begin
    AStream.Read(I, SizeOf(I));
    FStream.Clear;
    FStream.Size := I;
    AStream.Read(FStream.Memory^, I);
  end;
end;

procedure TJvDataEmbedded.WriteUnPublished(aStream: TStream);
var
  I: Integer;
begin
  if  DefinePropertyIs('EmbeddedData') then
  begin
    I := FStream.Size;
    AStream.Write(I, SizeOf(I));
    AStream.Write(FStream.Memory^, I);
  end;
end;

end.