unit kscale;
{
   Unit to scale real points to window points

   Author:  Vesa Lappalainen
   Date:    15.2.1998
   Changes: 19.3.1998/vl
            + joined to zooming form

}

interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls,kdouble,kpoint, kIniSave;

  {----------------------------------------------------------------------------}
type
  TScale = class(TPanel)
  private
    FFactor  : Double;
    FFac     : TDPoint;
    FOrigo   : TDPoint;
    FChanges : integer;
    FIni : TIniSave;
  protected
    procedure SetFactor(f:double); virtual;
    procedure TellOthers;           virtual;
    procedure Loaded; override;
  public
    Form : TForm;
    constructor Create(AOwner:TComponent); override;
    destructor Destroy; override;
    function DownScaleP(const p:TDPoint)   : TPoint;  virtual;
    function DownScaleDX(x:double) : integer;  virtual;
    function DownScaleDY(y:double) : integer;  virtual;
    function DownScaleDP(const dp:TDPoint) : TPoint;  virtual;
    function UpScaleP(ip:TPoint;p:TDPoint) : TDPoint; virtual;
    function UpScaleDP(idp:TPoint;dp:TDPoint): TDPoint; virtual;
    procedure FacChange(const p:TDPoint); virtual;
    procedure OrigoChange(const p:TDPoint); virtual;
    function  GetAsString : string; virtual;
    procedure SetAsString(value:string); virtual;
    procedure FormZoom; virtual;
  published
    property Factor : Double  Read FFactor Write SetFactor;
    property Fac    : TDPoint Read FFac Write FFac;
    property Origo  : TDPoint Read FOrigo Write FOrigo;
    property Changes : integer Read FChanges;
    property Ini : TIniSave read FIni write FIni;
    property AsString : string read GetAsString write SetAsString stored false;
  end; { TScale }

procedure Register;

implementation
uses kavesimu,scalezmf;


{------------------------------------------------------------------------------}
procedure Register;
begin
  RegisterComponents('Kave2000', [TScale]);
end;

{------------------------------------------------------------------------------}
{ TScale ======================================================================}
{------------------------------------------------------------------------------}
//-----------------------------------------------------------------------------
function TScale.DownScaleDX(x:double) : integer;
begin
  Result := Round(x*Fac.x);
end;

//-----------------------------------------------------------------------------
function TScale.DownScaleDY(y:double) : integer;
begin
  Result := Round(y*Fac.y);
end;

//-----------------------------------------------------------------------------
function TScale.DownScaleP(const p:TDPoint)   : TPoint; //   virtual;
begin
  Result.x := Round( p.x*Fac.x + Origo.x);
  Result.y := Round(-p.y*Fac.y + Origo.y);
end;

//-----------------------------------------------------------------------------
function TScale.DownScaleDP(const dp:TDPoint) : TPoint; //   virtual;
begin
  Result.x := Round(dp.x*Fac.x);
  Result.y := Round(dp.y*Fac.y);
end;


//-----------------------------------------------------------------------------
function TScale.UpScaleP(ip:TPoint;p:TDPoint) : TDPoint; //  virtual;
begin
  if ( Fac.x = 0 ) then p.x := ip.x-Origo.x
                   else p.x := (ip.x-Origo.x)/Fac.x;
  if ( Fac.y = 0 ) then p.y := (ip.y-Origo.y)
                   else p.y :=-(ip.y-Origo.y)/Fac.y;
  Result := p;
end;


//-----------------------------------------------------------------------------
function TScale.UpScaleDP(idp:TPoint;dp:TDPoint): TDPoint; //  virtual;
begin
  if ( Fac.x = 0 ) then dp.x := idp.x  else dp.x := (idp.x/Fac.x);
  if ( Fac.y = 0 ) then dp.y := idp.y  else dp.y := (idp.y/Fac.y);
  Result := dp;
end;

{------------------------------------------------------------------------------}
constructor TScale.Create(AOwner:TComponent);
begin
  inherited Create(AOwner);
  FFactor := 800.0/20000.0;
  Fac   := TDPoint.Create3(FFactor,FFactor,FacChange);
  Origo := TDPoint.Create3(320,72,OrigoChange);
  FChanges := 0;
  FIni          := TIniSave.Create(self);
  Ini.PropName  := 'AsString';
  Ini.GenName := '-'; 
end;

{------------------------------------------------------------------------------}
procedure TScale.SetFactor(f:double);
var ratio:double;
begin
  if ( FFactor = f ) then exit;
  if ( FFactor = 0 ) then begin
    FFactor  := f;
    Fac.SetXY(f,f);
  end
  else begin
    Ratio := f/FFactor;
    FFactor :=  FFactor*Ratio;
    Fac.Mul(Ratio);
  end;
end;

{------------------------------------------------------------------------------}
procedure TScale.TellOthers;
var i:integer;
begin
  for i:=0 to ControlCount-1 do begin
    if ( Controls[i] is TaSimuObject ) and
       ( (Controls[i] as TaSimuObject).Scale = self ) then
      (Controls[i] as TaSimuObject).DoScale(false);
  end;
end;


//-----------------------------------------------------------------------------
procedure TScale.FacChange(const p:TDPoint); //  virtual;
begin
  FFactor := abs(Fac.x);
  inc(FChanges);  TellOthers;
end;

//-----------------------------------------------------------------------------
procedure TScale.OrigoChange(const p:TDPoint); //  virtual;
begin
  inc(FChanges);  TellOthers;
end;


//-----------------------------------------------------------------------------
destructor TScale.Destroy; //  virtual;
begin
  Ini.Save;
  Ini.Free;
  FFac.Free;
  FOrigo.Free;
  inherited;
end;


//-----------------------------------------------------------------------------
procedure TScale.SetAsString(value:string); //  virtual;
begin
  if csDesigning in ComponentState then exit;
  Origo.X := ExtractIniDouble(value,',',Origo.X);
  Origo.Y := ExtractIniDouble(value,',',Origo.Y);
  Fac.X := ExtractIniDouble(value,',',Fac.X);
  Fac.Y := ExtractIniDouble(value,',',Fac.Y);
end;


//-----------------------------------------------------------------------------
function  TScale.GetAsString : string; //  virtual;
begin
  Result := DoubleToIniStr(Origo.X,1) + ',' +
            DoubleToIniStr(Origo.Y,1) + ',' +
            DoubleToIniStr(Fac.X,5) + ',' +
            DoubleToIniStr(Fac.Y,5);
end;


//-----------------------------------------------------------------------------
procedure TScale.Loaded; //  override;
begin
  inherited;
  if ( csDesigning in ComponentState ) then exit;
  Ini.Load;
end;


//-----------------------------------------------------------------------------
procedure TScale.FormZoom; //  virtual;
begin
  if ( assigned(Form) ) then begin Form.Show; exit; end; 
  Form := TFormScaleZoom.Create(nil);
  if ( Form = nil ) then exit;
  (Form as TFormScaleZoom).Scale := self;
  Form.Show;
end;






end.