300分相求：失量图的绘制和操作方法（类似于coreldraw,freehand等） (300分)

:='.';
  Val(S,F,Code);
  Result:=Code = 0;
end;
{------------------------------------------------------------------------------}

function InRange(Test,Min,Max: Integer): Boolean;
begin
  Result:=(Test >= Min) and (Test <= Max);
end;

function Angle(X1,Y1,X2,Y2: TFloat): TFloat;
var
  Dx: TFloat;
  Dy: TFloat;
begin
  Result:=0;
  Dx:=X2 - X1;
  Dy:=Y2 - Y1;
  if Dx <> 0 then Result:=ArcTan(Dy / Dx) / Pi * 180;
  if Dx < 0 then Result:=-Result;
end;

procedure TextOutRotate(ACanvas: TCanvas; X,Y: Integer; Ang: Word; S: Str32);
var
  LogRec: TLogFont;
  OldFontHandle: HFont;
  NewFontHandle: HFont;
begin
  GetObject(ACanvas.Font.Handle,SizeOf(LogRec),@LogRec);
  LogRec.lfEscapement:=Ang;
  NewFontHandle:=CreateFontIndirect(LogRec);
  OldFontHandle:=SelectObject(ACanvas.Handle,NewFontHandle);
  ACanvas.TextOut(X,Y,S);
  NewFontHandle:=SelectObject(ACanvas.Handle,OldFontHandle);
  DeleteObject(NewFontHandle);
end;

{ TPositions }

constructor TPositions.Create;
begin
  inherited Create;
  FXAxisLeft:=60;
  FXAxisRight:=15;
  FYAxisTop:=30;
  FYAxisBottom:=50;
  FTitleTop:=5;
  FTitleLeft:=0;
  FXAxisTitle:=20;
  FYAxisTitle:=5;
  FOnChange:=nil;
end;

procedure TPositions.SetInteger(Index, Value: Integer);
begin
  case Index of
    0 : FXAxisLeft:=Value;
    1 : FXAxisRight:=Value;
    2 : FYAxisTop:=Value;
    3 : FYAxisBottom:=Value;
    4 : FTitleTop:=Value;
    5 : FTitleLeft:=Value;
    6 : FXAxisTitle:=Value;
    7 : FYAxisTitle:=Value;
  end;
  if Assigned(FOnChange) then FOnChange(Self);
end;

{ TFonts }

constructor TFonts.Create;
begin
  inherited Create;
  FAxisScale:=TFont.Create;
  FAxisScale.Name:='small fonts';
  FAxisScale.Size:=7;
  FAxisScale.Color:=clNavy;

  FAxisTitle:=TFont.Create;
  FAxisTitle.Name:='arial';
  FAxisTitle.Size:=8;
  FAxisTitle.Style:=[fsBold];
  FAxisTitle.Color:=clMaroon;

  FGraphTitle:=TFont.Create;
  FGraphTitle.Name:='arial';
  FGraphTitle.Size:=10;
  FGraphTitle.Style:=[fsBold];
  FGraphTitle.Color:=clMaroon;
  FOnChange:=nil;
end;

destructor TFonts.Destroy;
begin
  FAxisScale.Free;
  FAxisTitle.Free;
  FGraphTitle.Free;
  inherited Destroy;
end;

procedure TFonts.SetFont(Index: Integer; Value: TFont);
begin
  case Index of
    0 : FAxisScale.Assign(Value);
    1 : FAxisTitle.Assign(Value);
    2 : FGraphTitle.Assign(Value);
  end;
  if Assigned(FOnChange) then FOnChange(Self);
end;

{ TColors }

constructor TColors.Create;
begin
  inherited Create;
  FAxisBkGnd:=clSilver;
  FTickColor:=clBlack;
  FGraphBkGnd:=clBlack;
  FMainGridColor:=clGray;
  FSubGridColor:=clGray;
  FOnChange:=nil;
end;
{------------------------------------------------------------------------------}

procedure TColors.SetColor(Index: Integer; Value: TColor);
begin
  case Index of
    0: FAxisBkGnd:=Value;
    1: FTickColor:=Value;
    2: FGraphBkGnd:=Value;
    3: FMainGridColor:=Value;
    4: FSubGridColor:=Value;
  end;
  if Assigned(FOnChange) then FOnChange(Self);
end;

{ TAxis }

constructor TAxis.Create;
begin
  inherited Create;
  FTitle:='Axis-Title';
  FLength:=200;
  FMin:=0;
  FMax:=10;
  FMinSave:=FMin;
  FMaxSave:=FMax;
  FZoom:=1.0;
  FMainTicks:=5;
  FSubTicks:=5;
  FMainTickLen:=10;
  FSubTickLen:=5;
  FDecimals:=2;
  FPan:=0;
  FPanSubTicks:=0;
  FShowMainGrid:=True;
  FShowSubGrid:=False;
  FOnChange:=nil;
  CalcAxis;
end;
{------------------------------------------------------------------------------}

procedure TAxis.CalcAxis;
begin
  FValuePerMainTick:=(FMax - FMin) / FMainTicks;
  FFactor:=FLength / (FMax - FMin);
  FTicks:=FMainTicks * FSubTicks;
  FPixelsPerSubTick:=FLength / FTicks;
  FValuePerPixel:=FValuePerMainTick / (FSubTicks * FPixelsPerSubTick);
end;
{------------------------------------------------------------------------------}

function TAxis.Value(APosition: Integer): TFloat;
begin
  Result:=FMin + (FValuePerPixel * (APosition - FPan));
end;
{------------------------------------------------------------------------------}

function TAxis.Pixel(APosition: TFloat): Integer;
begin
  Result:=FPan + Round((APosition - FMin) * FFactor);
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetZoom(Value: TFloat);
var
  Zoom,Dif: TFloat;
begin
  Dif:=FMax - FMin;
  Zoom:=Dif / (Value * FZoom);
  FMin:=FMin - Dif + Zoom;
  FMax:=FMax + Dif - Zoom;
  CalcAxis;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetCenter(C: TFloat);
var
  Dif: TFloat;
begin
  Dif:=(FMax - FMin) / 2;
  FMin:=C - Dif;
  FMax:=C + Dif;
  CalcAxis;
end;
{------------------------------------------------------------------------------}

function TAxis.GetCenter: TFloat;
begin
  Result:=FMin + ((FMax - FMin) / 2);
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetLeftBottom(L: TFloat);
var
  Dif: TFloat;
begin
  Dif:=FMax - FMin;
  FMin:=L;
  FMax:=FMin + Dif;
  CalcAxis;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetRightTop(R: TFloat);
var
  Dif: TFloat;
begin
  Dif:=FMax - FMin;
  FMax:=R;
  FMin:=FMax - Dif;
  CalcAxis;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetMinMax(AMin,AMax: TFloat);
begin
  if (AMin < FMax) and (AMax > FMin) then
  begin
    FMin:=AMin;
    FMax:=AMax;
  end;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetTitle(const Value: Str32);
begin
  if FTitle <> Value then
  begin
    FTitle:=Value;
    if Assigned(FOnChange) then FOnChange(Self);
  end;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetLength(Value: Integer);
begin
  if FLength <> Value then
  begin
    FLength:=Value;
    CalcAxis;
    if Assigned(FOnChange) then FOnChange(Self);
  end;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetFloat(Index: Integer; Value: TFloat);
begin
  case Index of
    0: if (Value <> FMin) and (Value < FMax) then
       begin
         FMin:=Value;
         FMinSave:=FMin;
         CalcAxis;
         if Assigned(FOnChange) then FOnChange(Self);
       end;
    1: if (Value <> FMax) and (Value > FMin) then
       begin
         FMax:=Value;
         FMaxSave:=Value;
         CalcAxis;
         if Assigned(FOnChange) then FOnChange(Self);
       end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetMax(Value: TFloat);
begin
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetByte(Index: Integer; Value: Byte);
begin
  case Index of
    0 : if Value > 0 then FMainTicks:=Value;
    1 : FSubTicks:=Value;
    2 : FMainTickLen:=Value;
    3 : FSubTickLen:=Value;
    4 : if Value < 5 then FDecimals:=Value;
  end;
  CalcAxis;
  if Assigned(FOnChange) then FOnChange(Self);
end;
{------------------------------------------------------------------------------}

procedure TAxis.SetBoolean(Index: Integer; Value: Boolean);
begin
  case Index of
    0 : FShowMainGrid:=Value;
    1 : FShowSubGrid:=Value;
  end;
  if Assigned(FOnChange) then FOnChange(Self);
end;
{------------------------------------------------------------------------------}

constructor TXYGraph.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  IsLoaded:=False;
  BoundsChanged:=False;
  ZoomAspectRatio:=True;
  PanCurves:=False;
  CPMatch:=False;
  FZoom:=1.0;
  MaxZoom:=5.0;
  SetBounds(Left,Top,400,300);

  FXAxis:=TAxis.Create;
  FYAxis:=TAxis.Create;
  FColors:=TColors.Create;
  FFonts:=TFonts.Create;
  FPositions:=TPositions.Create;
  FCurveList:=TList.Create;
  DrawBmp:=TBitMap.Create;

  FControls:=TControls.Create(Self);

  FHintPanel:=THintPanel.Create(Self);
  FHintPanel.Parent:=Self;
  FHintPanel.Visible:=True;

  FXAxis.OnChange:=OnChangePaint;
  FYAxis.OnChange:=OnChangePaint;
  FFonts.OnChange:=OnChangePaint;
  FColors.OnChange:=OnChangePaint;
  FPositions.OnChange:=OnChangePaint;

  OnDblClick:=DblClicked;

  FGraphTitle:='Graph-Title';
  XAxis.Title:='X-Axis-Title';
  YAxis.Title:='Y-Axis-Title';
end;
{------------------------------------------------------------------------------}

destructor TXYGraph.Destroy;
var
  I: Integer;
begin
  FXAxis.Free;
  FYAxis.Free;
  FPositions.Free;
  FColors.Free;
  FFonts.Free;
  for I:=0 to Pred(FCurveList.Count) do
  begin
    FCurve:=FCurveList.Items[I];
    FCurve.Free;
  end;
  FCurveList.Free;
  DrawBmp.Free;
  FHintPanel.Free;
  FControls.Free;

  inherited Destroy;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.Loaded;
begin
  inherited Loaded;
  XAxis.FMinSave:=XAxis.FMin;
  XAxis.FMaxSave:=XAxis.FMax;
  YAxis.FMinSave:=YAxis.FMin;
  YAxis.FMaxSave:=YAxis.FMax;

  XAxis.CalcAxis;
  YAxis.CalcAxis;

  ZoomSave:=Zoom;

  SetMode(gmNone);
  IsLoaded:=True;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetBounds(ALeft,ATop,AWidth,AHeight: Integer);
begin
  inherited SetBounds(ALeft,ATop,AWidth,AHeight);
  BoundsChanged:=True;
end;
{------------------------------------------------------------------------------}

function TXYGraph.XAxisPixel(Value: TFloat): Integer;
begin
  Result:=Positions.XAxisLeft + XAxis.Pixel(Value);
end;
{------------------------------------------------------------------------------}

function TXYGraph.YAxisPixel(Value: TFloat): Integer;
begin
  Result:=Height - Positions.YAxisBottom - YAxis.Pixel(Value);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.Paint;
var
  R: TRect;
  H,I,J: Integer;
  X,Y: TFloat;
  Size: Word;
  PA: PPointArray;
  PText: PTextRec;
  PMark: PMarkRec;
begin
  if BoundsChanged then
  begin
    XAxis.Length:=Width - Positions.XAxisLeft - Positions.XAxisRight;
    YAxis.Length:=Height - Positions.YAxisTop - Positions.YAxisBottom;
    BoundsChanged:=False;
  end;

  if CPMatch or (FMode = gmCursor) then ClearMarkBox;

  DrawBmp.Width:=Width;
  DrawBmp.Height:=Height;
  DrawBmp.Canvas.Pen.Width:=1;

  DrawBmp.Canvas.Brush.Color:=FColors.FGraphBkGnd;
  DrawBmp.Canvas.FillRect(Rect(FPositions.XAxisLeft,FPositions.YAxisTop,
                     Width - Positions.XAxisRight,Height - Positions.YAxisBottom));
  DrawBmp.Canvas.Brush.Color:=FColors.AxisBkGnd;
  DrawBmp.Canvas.FillRect(Rect(0,0,Positions.XAxisLeft,Height));
  DrawBmp.Canvas.FillRect(Rect(Positions.XAxisLeft,0,Width,Positions.YAxisTop));
  DrawBmp.Canvas.FillRect(Rect(0,Height - Positions.YAxisBottom,Width,Height));
  DrawBmp.Canvas.FillRect(Rect(Width - Positions.XAxisRight,Positions.YAxisTop,Width,Height - FPositions.YAxisBottom));

  DrawBmp.Canvas.Brush.Color:=clGray;
  R:=Rect(0,0,Width,Height);
  DrawBmp.Canvas.FrameRect(R);
  InflateRect(R,-1,-1);
  DrawBmp.Canvas.Brush.Color:=clWhite;
  DrawBmp.Canvas.FrameRect(R);
  DrawBmp.Canvas.Brush.Style:=bsClear;

  if Length(FGraphTitle) > 0 then
  begin
    DrawBmp.Canvas.Font:=FFonts.FGraphTitle;
    if Positions.TitleLeft = 0 then
      DrawBmp.Canvas.TextOut(Width div 2 - DrawBmp.Canvas.TextWidth(FGraphTitle) div 2,
                        Positions.TitleTop,FGraphTitle)
    else DrawBmp.Canvas.TextOut(Positions.TitleLeft,Positions.TitleTop,FGraphTitle);
  end;

  DrawXAxis;
  DrawYAxis;

  HClip:=CreateRectRgn(Positions.XAxisLeft,Positions.YAxisTop,
                       Width - Positions.XAxisRight + 1,Height - Positions.YAxisBottom + 1);
  SelectClipRgn(DrawBmp.Canvas.Handle,HClip);
  Size:=GetMaxPoints * SizeOf(TPointArray);
  GetMem(PA,Size);

  for H:=0 to Pred(FCurveList.Count) do
  begin
    FCurve:=FCurveList.Items[H];
    if FCurve.Enabled and (FCurve.FPoints.Count > 0) then
    begin
      DrawBmp.Canvas.Pen.Color:=FCurve.Color;
      DrawBmp.Canvas.Pen.Style:=FCurve.PenStyle;
      DrawBmp.Canvas.Pen.Width:=FCurve.LineWidth;
      J:=Pred(FCurve.FPoints.Count);
      for I:=0 to J do
      begin
        FCurve.GetPoint(I,X,Y);
        PA^[I].x:=XAxisPixel(X);
        PA^[I].y:=YAxisPixel(Y);
      end;
      DrawBmp.Canvas.PolyLine(Slice(PA^,Succ(J)));
      for I:=0 to Pred(FCurve.FTexts.Count) do
      begin
        PText:=FCurve.FTexts.Items[I];
        DrawBmp.Canvas.Font:=FCurve.FFont;
        DrawBmp.Canvas.Font.Color:=PText^.TextColor;
        DrawBmp.Canvas.Brush.Style:=bsClear;
        FCurve.GetPoint(PText^.PointIndex,X,Y);
        DrawBmp.Canvas.TextOut(XAxisPixel(X) + PText^.XOfs,
                               YAxisPixel(Y) + PText^.YOfs,PText^.Text);
      end;
      for I:=0 to Pred(FCurve.FMarks.Count) do
      begin
        PMark:=FCurve.FMarks.Items[I];
        FCurve.GetPoint(PMark^.PointIndex,X,Y);
        DrawMark(DrawBmp.Canvas,PMark^.MarkType,PMark^.MarkColor,
                 FCurve.FMarkSize,XAxisPixel(X),YAxisPixel(Y));
      end;
    end;
  end;
  FreeMem(PA,Size);
  DeleteObject(HClip);

  DrawBmp.Canvas.Pen.Style:=psSolid;
  R:=ClientRect;
  Canvas.CopyRect(R,DrawBmp.Canvas,R);

  if CPMatch or (FMode = gmCursor) then DrawMarkBox;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OnChangePaint(Sender: TObject);
begin
  if Sender = FPositions then
  begin
    XAxis.Length:=Width - FPositions.XAxisLeft - FPositions.XAxisRight;
    YAxis.Length:=Height - FPositions.YAxisTop - FPositions.YAxisBottom;
  end;
  Application.ProcessMessages;
  if IsLoaded then Paint;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DrawXAxis;
var
  I,X,Y: Integer;
  Pos: Integer;
  VPos: Integer;
  S: string[12];
begin
  DrawBmp.Canvas.Font:=FFonts.AxisScale;
  DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
  Y:=0;
  VPos:=Height - FPositions.YAxisBottom;
  FXAxis.PanSubTicks:=Round(FXAxis.Pan / FXAxis.PixelsPerSubTick);
  if FXAxis.Pan > 0 then
  begin
    if FXAxis.PanSubTicks >= FXAxis.SubTicks then
    begin
      FXAxis.Pan:=FXAxis.Pan - Round(FXAxis.PanSubTicks * FXAxis.PixelsPerSubTick);
      FXAxis.PanSubTicks:=0;
      FXAxis.SetMinMax(FXAxis.Min - FXAxis.ValuePerMainTick,
                       FXAxis.Max - FXAxis.ValuePerMainTick);
    end;
    for X:=-FXAxis.PanSubTicks to FXAxis.Ticks - FXAxis.PanSubTicks do
    begin
      Pos:=FPositions.XAxisLeft + Round(FXAxis.FPixelsPerSubTick * X) + FXAxis.Pan;
      if (Pos >= FPositions.XAxisLeft) and (Pos <= Width - FPositions.XAxisRight) then
      begin
        DrawBmp.Canvas.MoveTo(Pos,VPos);
        if X mod FXAxis.SubTicks = 0 then
        begin
          DrawBmp.Canvas.LineTo(Pos,VPos + FXAxis.MainTickLen);
          S:=FloatToStrF(FXAxis.Min + (Y * FXAxis.ValuePerMainTick),ffFixed,7,FXAxis.Decimals);
          for I:=1 to Length(S) do
          if S[I] = ' ' then Delete(S,I,1);
          I:=DrawBmp.Canvas.TextWidth(S);
          DrawBmp.Canvas.TextOut(Pos - I div 2,VPos + FXAxis.MainTickLen,S);
          if FXAxis.ShowMainGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.MainGridColor;
            DrawBmp.Canvas.MoveTo(Pos,FPositions.YAxisTop);
            DrawBmp.Canvas.LineTo(Pos,Height - FPositions.YAxisBottom);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end
        else
        begin
          DrawBmp.Canvas.LineTo(Pos,VPos + FXAxis.SubTickLen);
          if FXAxis.ShowSubGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.SubGridColor;
            DrawBmp.Canvas.MoveTo(Pos,FPositions.YAxisTop);
            DrawBmp.Canvas.LineTo(Pos,Height - FPositions.YAxisBottom);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end;
      end;
      if X mod FXAxis.SubTicks = 0 then Inc(Y);
    end;
  end
  else
  begin
    if FXAxis.PanSubTicks <= -FXAxis.SubTicks then
    begin
      FXAxis.Pan:=FXAxis.Pan - Round(FXAxis.PanSubTicks * FXAxis.PixelsPerSubTick);
      FXAxis.PanSubTicks:=0;
      FXAxis.SetMinMax(FXAxis.Min + FXAxis.ValuePerMainTick,
                       FXAxis.Max + FXAxis.ValuePerMainTick);
    end;
    for X:=FXAxis.Ticks - FXAxis.PanSubTicks downto 0 - FXAxis.PanSubTicks do
    begin
      Pos:=FPositions.XAxisLeft + Round(FXAxis.FPixelsPerSubTick * X) + FXAxis.Pan;
      if (Pos >= FPositions.XAxisLeft) and (Pos <= Width - FPositions.XAxisRight) then
      begin
        DrawBmp.Canvas.MoveTo(Pos,VPos);
        if X mod FXAxis.SubTicks = 0 then
        begin
          DrawBmp.Canvas.LineTo(Pos,VPos + FXAxis.MainTickLen);
          S:=FloatToStrF(FXAxis.Max - (Y * FXAxis.ValuePerMainTick),ffFixed,7,FXAxis.Decimals);
          for I:=1 to Length(S) do if S[I] = ' ' then Delete(S,I,1);
          I:=DrawBmp.Canvas.TextWidth(S);
          DrawBmp.Canvas.TextOut(Pos - I div 2,VPos + FXAxis.MainTickLen,S);
          if FXAxis.ShowMainGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.MainGridColor;
            DrawBmp.Canvas.MoveTo(Pos,FPositions.YAxisTop);
            DrawBmp.Canvas.LineTo(Pos,Height - FPositions.YAxisBottom);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end
        else
        begin
          DrawBmp.Canvas.LineTo(Pos,VPos + FXAxis.SubTickLen);
          if FXAxis.ShowSubGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.SubGridColor;
            DrawBmp.Canvas.MoveTo(Pos,FPositions.YAxisTop);
            DrawBmp.Canvas.LineTo(Pos,Height - FPositions.YAxisBottom);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end;
      end;
      if X mod FXAxis.SubTicks = 0 then Inc(Y);
    end;
  end;
  DrawBmp.Canvas.Pen.Color:=FColors.GraphBkGnd;
  DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,VPos);
  DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,VPos);
  DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,FPositions.YAxisTop);
  DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,FPositions.YAxisTop);

  I:=DrawBmp.Canvas.TextWidth(XAxis.Title);
  X:=FPositions.XAxisLeft + XAxis.Length div 2 - I div 2;
  DrawBmp.Canvas.Font:=FFonts.AxisTitle;
  DrawBmp.Canvas.TextOut(X,Height - FPositions.FXAxisTitle,XAxis.Title);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DrawYAxis;
var
  I,H,X,Y: Integer;
  Pos: Integer;
  S: string[12];
begin
  DrawBmp.Canvas.Font:=FFonts.AxisScale;
  DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
  H:=DrawBmp.Canvas.TextHeight('0');
  Y:=0;
  FYAxis.PanSubTicks:=Round(FYAxis.Pan / FYAxis.PixelsPerSubTick);
  if FYAxis.Pan > 0 then
  begin
    if FYAxis.PanSubTicks >= FYAxis.SubTicks then
    begin
      FYAxis.Pan:=FYAxis.Pan - Round(FYAxis.PanSubTicks * FYAxis.PixelsPerSubTick);
      FYAxis.PanSubTicks:=0;
      FYAxis.SetMinMax(FYAxis.Min - FYAxis.ValuePerMainTick,
                       FYAxis.Max - FYAxis.ValuePerMainTick);
    end;
    for X:=-FYAxis.PanSubTicks to FYAxis.Ticks - FYAxis.PanSubTicks do
    begin
      Pos:=Height - FPositions.YAxisBottom - Round(FYAxis.FPixelsPerSubTick * X) - FYAxis.Pan;
      if (Pos >= FPositions.YAxisTop) and (Pos <= Height - FPositions.YAxisBottom) then
      begin
        DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
        if X mod FYAxis.SubTicks = 0 then
        begin
          DrawBmp.Canvas.LineTo(FPositions.XAxisLeft - FYAxis.MainTickLen,Pos);
          S:=FloatToStrF(FYAxis.Min + (Y * FYAxis.ValuePerMainTick),ffFixed,7,FYAxis.Decimals);
          for I:=1 to Length(S) do
          if S[I] = ' ' then Delete(S,I,1);
          I:=DrawBmp.Canvas.TextWidth(S);
          DrawBmp.Canvas.TextOut(FPositions.XAxisLeft - FYAxis.MainTickLen - I,Pos - H div 2,S);
          if FYAxis.ShowMainGrid and (Pos <> FPositions.YAxisTop)
                                and (Pos <> Height - FPositions.YAxisBottom) then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.MainGridColor;
            DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
            DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,Pos);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end
        else
        begin
          DrawBmp.Canvas.LineTo(FPositions.XAxisLeft - FYAxis.SubTickLen,Pos);
          if FYAxis.ShowSubGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.SubGridColor;
            DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
            DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,Pos);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end;
      end;
      if X mod FYAxis.SubTicks = 0 then Inc(Y);
    end;
  end
  else
  begin
    if FYAxis.PanSubTicks <= -FYAxis.SubTicks then
    begin
      FYAxis.Pan:=FYAxis.Pan - Round(FYAxis.PanSubTicks * FYAxis.PixelsPerSubTick);
      FYAxis.PanSubTicks:=0;
      FYAxis.SetMinMax(FYAxis.Min + FYAxis.ValuePerMainTick,
                       FYAxis.Max + FYAxis.ValuePerMainTick);
    end;
    for X:=FYAxis.Ticks - FYAxis.PanSubTicks downto 0 - FYAxis.PanSubTicks do
    begin
      Pos:=Height - FPositions.YAxisBottom - Round(FYAxis.FPixelsPerSubTick * X) - FYAxis.Pan;
      if (Pos >= FPositions.YAxisTop) and (Pos <= Height - FPositions.YAxisBottom) then
      begin
        DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
        if X mod FYAxis.SubTicks = 0 then
        begin
          DrawBmp.Canvas.LineTo(FPositions.XAxisLeft - FYAxis.MainTickLen,Pos);
          S:=FloatToStrF(FYAxis.Max - (Y * FYAxis.ValuePerMainTick),ffFixed,7,FYAxis.Decimals);
          for I:=1 to Length(S) do
          if S[I] = ' ' then Delete(S,I,1);
          I:=DrawBmp.Canvas.TextWidth(S);
          DrawBmp.Canvas.TextOut(FPositions.XAxisLeft - FYAxis.MainTickLen - I,Pos - H div 2,S);
          if FYAxis.ShowMainGrid and (Pos <> FPositions.YAxisTop)
                                and (Pos <> Height - FPositions.YAxisBottom) then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.MainGridColor;
            DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
            DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,Pos);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end
        else
        begin
          DrawBmp.Canvas.LineTo(FPositions.XAxisLeft - FYAxis.SubTickLen,Pos);
          if FYAxis.ShowSubGrid then
          begin
            DrawBmp.Canvas.Pen.Color:=FColors.SubGridColor;
            DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Pos);
            DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,Pos);
            DrawBmp.Canvas.Pen.Color:=FColors.FTickColor;
          end;
        end;
      end;
      if X mod FYAxis.SubTicks = 0 then Inc(Y);
    end;
  end;
  DrawBmp.Canvas.Pen.Color:=FColors.GraphBkGnd;
  DrawBmp.Canvas.MoveTo(FPositions.XAxisLeft,Height - FPositions.YAxisBottom);
  DrawBmp.Canvas.LineTo(FPositions.XAxisLeft,FPositions.YAxisTop - 1);
  DrawBmp.Canvas.MoveTo(Width - FPositions.XAxisRight,Height - FPositions.YAxisBottom);
  DrawBmp.Canvas.LineTo(Width - FPositions.XAxisRight,FPositions.YAxisTop - 1);

  I:=DrawBmp.Canvas.TextWidth(YAxis.Title);
  Y:=Height - FPositions.YAxisBottom - YAxis.Length div 2 + I div 2;
  DrawBmp.Canvas.Font:=FFonts.AxisTitle;
  TextOutRotate(DrawBmp.Canvas,FPositions.FYAxisTitle,Y,900,YAxis.Title);
end;
{------------------------------------------------------------------------------}

function TXYGraph.GetMaxPoints: Integer;
var
  I,Max: Integer;
begin
  Max:=0;
  for I:=0 to Pred(FCurveList.Count) do
  begin
    FCurve:=FCurveList.Items[I];
    if FCurve.FPoints.Count > Max then Max:=FCurve.FPoints.Count;
  end;
  Result:=Max;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetEditEnable(Value: Boolean);
begin
  if Assigned(FControls.XOut) then FControls.XOut.Enabled:=Value;
  if Assigned(FControls.YOut) then FControls.YOut.Enabled:=Value;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutMode(const Mode: Str32);
begin
  if Assigned(FControls.FMode) then
  begin
    if (FControls.FMode is TPanel) then TPanel(FControls.FMode).Caption:=Mode;
    if (TObject(FControls.FMode) is TStatusPanel) then TStatusPanel(FControls.FMode).Text:=Mode;
    if (FControls.FMode is TLabel) then TLabel(FControls.FMode).Caption:=Mode;
    if (FControls.FMode is TStaticText) then TStaticText(FControls.FMode).Caption:=Mode;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutCurve(const Curve: Str32);
begin
  if Assigned(FControls.FCurve) then
  begin
    if (FControls.FCurve is TPanel) then TPanel(FControls.FCurve).Caption:=Curve;
    if (TObject(FControls.FCurve) is TStatusPanel) then TStatusPanel(FControls.FCurve).Text:=Curve;
    if (FControls.FCurve is TLabel) then TLabel(FControls.FCurve).Caption:=Curve;
    if (FControls.FCurve is TStaticText) then TStaticText(FControls.FCurve).Caption:=Curve;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutItem(Item: Integer);
var
  Text: Str32;
begin
  if Item > -1 then Text:=IntToStr(Item) else Text:='';
  if Assigned(FControls.FItem) then
  begin
    if (FControls.FItem is TPanel) then TPanel(FControls.FItem).Caption:=Text;
    if (TObject(FControls.FItem) is TStatusPanel) then TStatusPanel(FControls.FItem).Text:=Text;
    if (FControls.FItem is TLabel) then TLabel(FControls.FItem).Caption:=Text;
    if (FControls.FItem is TStaticText) then TStaticText(FControls.FItem).Caption:=Text;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutColor(Color: TColor);
begin
  if Assigned(FControls.FColor) then
  begin
    if (FControls.FColor is TPanel) then TPanel(FControls.FColor).Color:=Color;
    if (FControls.FColor is TLabel) then TLabel(FControls.FColor).Color:=Color;
    if (FControls.FColor is TStaticText) then TStaticText(FControls.FColor).Color:=Color;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutXY(Fx,Fy: TFloat);
var
  Sx,Sy: Str32;
begin
  Sx:=FloatToStrF(Fx,ffFixed,7,3);
  Sy:=FloatToStrF(Fy,ffFixed,7,3);

  if Assigned(FControls.FXOut) then
  begin
    if (FControls.FXOut is TEdit) then TEdit(FControls.FXOut).Text:=Sx;
    if (FControls.FXOut is TPanel) then TPanel(FControls.FXOut).Caption:=Sx;
    if (TObject(FControls.FXOut) is TStatusPanel) then TStatusPanel(FControls.FXOut).Text:=Sx;
    if (FControls.FXOut is TLabel) then TLabel(FControls.FXOut).Caption:=Sx;
    if (FControls.FXOut is TStaticText) then TStaticText(FControls.FXOut).Caption:=Sx;
  end;

  if Assigned(FControls.FYOut) then
  begin
    if (FControls.FYOut is TEdit) then TEdit(FControls.FYOut).Text:=Sy;
    if (FControls.FYOut is TPanel) then TPanel(FControls.FYOut).Caption:=Sy;
    if (TObject(FControls.FYOut) is TStatusPanel) then TStatusPanel(FControls.FYOut).Text:=Sy;
    if (FControls.FYOut is TLabel) then TLabel(FControls.FYOut).Caption:=Sy;
    if (FControls.FYOut is TStaticText) then TStaticText(FControls.FYOut).Caption:=Sy;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.OutAngle(A: TFloat);
var
  Sa: Str32;
begin
  if Assigned(FControls.FAngle) then
  begin
    if A > 9.9E16 then Sa:='' else Sa:=FloatToStrF(A,ffFixed,7,3);
    if (FControls.FAngle is TPanel) then TPanel(FControls.FAngle).Caption:=Sa;
    if (TObject(FControls.FAngle) is TStatusPanel) then TStatusPanel(FControls.FAngle).Text:=Sa;
    if (FControls.FAngle is TLabel) then TLabel(FControls.FAngle).Caption:=Sa;
    if (FControls.FAngle is TStaticText) then TStaticText(FControls.FAngle).Caption:=Sa;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoPan(Dx,Dy: Integer);
begin
  if not PanCurves then
  begin
    OutMode('Pan: Graph');
    SetEditEnable(False);
    if Dx <> 0 then FXAxis.Pan:=FXAxis.Pan + Dx;
    if Dy <> 0 then FYAxis.Pan:=FYAxis.Pan - Dy;
    Paint;
  end
  else
  begin
    OutMode('Pan: Curves');
    SetEditEnable(True);
    ChangeCurveOfs(Dx * FXAxis.FValuePerPixel,-Dy * FYAxis.FValuePerPixel,True);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoZoom(Dx,Dy: Integer);
var
  AXDif,AYDif: TFloat;
  XDif,YDif: TFloat;
  ZFx,ZFy: TFloat;
  Factor: TFloat;
  XStep,YStep: TFloat;
begin
  AXDif:=FXAxis.FMax - FXAxis.FMin;
  AYDif:=FYAxis.FMax - FYAxis.FMin;
  XDif:=FXAxis.FMaxSave - FXAxis.FMinSave;
  YDif:=FYAxis.FMaxSave - FYAxis.FMinSave;
  ZFx:=1.0;
  ZFy:=1.0;
  if AXDif <> 0.0 then ZFx:=XDif / AXDif;
  if AYDif <> 0.0 then ZFy:=YDif / AYDif;

  XStep:=0.0;
  YStep:=0.0;

  if Dx > 0 then XStep:=-0.02 else if Dx < 0 then XStep:=0.02;
  if Dy > 0 then YStep:=-0.02 else if Dy < 0 then YStep:=0.02;

  if ZoomAspectRatio then
  begin
    OutMode('Zoom: Aspect');
    OutXY(ZFx,ZFx);
    Factor:=FXAxis.Zoom + XStep;
    if ((Factor < 1) and (ZFx < FMaxZoom)) or
       ((Factor > 1) and (ZFx > 1 / FMaxZoom)) then
    begin
      FXAxis.SetZoom(Factor);
      FYAxis.SetZoom(Factor);
      Paint;
    end;
  end
  else 
  begin
    OutMode('Zoom: Free');
    OutXY(ZFx,ZFy);
    Factor:=FXAxis.Zoom + XStep;
    if ((Factor < 1) and (ZFx < FMaxZoom)) or
       ((Factor > 1) and (ZFx > 1 / FMaxZoom)) then FXAxis.SetZoom(Factor);
    Factor:=FXAxis.Zoom - YStep;
    if ((Factor < 1) and (ZFy < FMaxZoom)) or
       ((Factor > 1) and (ZFy > 1 / FMaxZoom)) then FYAxis.SetZoom(Factor);
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoMouse(X,Y: Integer);
begin
  if FMode = gmCursor then OutMode('Mouse: Cursor')
    else OutMode('Mouse: Position');
  OutXY(XAxis.Value(X - Positions.XAxisLeft),
        YAxis.Value(Height - Y - Positions.YAxisBottom));
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetMeasureCursor(X,Y: Integer);
begin
  ClearMarkBox;
  OutMode('Mouse: Cursor');
  OutXY(0,0);
  ClearMarkBox;
  CPMatch:=False;
  CPx:=XAxis.Value(X - Positions.XAxisLeft);
  CPy:=YAxis.Value(Height - Y - Positions.YAxisBottom);
  DrawMarkBox;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoMeasureCursor(X,Y: Integer);
begin
  OutXY(XAxis.Value(X - Positions.XAxisLeft) - CPx,
        YAxis.Value(Height - Y - Positions.YAxisBottom) - CPy);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoMove(Dx,Dy: Integer);
begin
  if CPMatch then
  begin
    CPx:=CPx + Dx * FXAxis.ValuePerPixel;
    CPy:=CPy - Dy * FYAxis.ValuePerPixel;
    ChangePoint(CPCurve,CPIndex,CPx,CPy);
    OutXY(CPx,CPy);
    OutMode('Edit: Move');
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoCheckCP(X,Y: Integer);
var
  Fx,Fy: TFloat;
begin
  CheckCurvePoints(X - Positions.XAxisLeft,Height - Y - Positions.YAxisBottom);
  if CPMatch then
  begin
    if ((LastCPCurve <> CPCurve) or (LastCPIndex <> CPIndex)) then
    begin
      OutXY(CPx,CPy);
      FCurve:=FCurveList.Items[CPCurve];
      OutCurve(FCurve.Name);
      OutItem(CPIndex);
      OutColor(FCurve.Color);
      LastCPCurve:=CPCurve;
      LastCPIndex:=CPIndex;
      if CPIndex < Pred(FCurve.FPoints.Count) then
      begin
        GetPoint(CPCurve,Succ(CPIndex),Fx,Fy);
        if Assigned(FControls.FAngle) then OutAngle(Angle(CPx,CPy,Fx,Fy));
      end;
    end;
  end
  else if not CPMatch then
  begin
    OutCurve('');
    OutItem(-1);
    OutColor(FColors.FGraphBkGnd);
    OutAngle(9.9E18);
    LastCPCurve:=-1;
    LastCPIndex:=-1;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DblClicked(Sender: TObject);
begin
  Reset;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.MouseDown(Button: TMouseButton; Shift: TShiftState; X,Y: Integer);
var
  Cx,Cy,Dx,Dy,Fx,Fy: TFloat;
  N: Integer;
begin
  inherited MouseDown(Button,Shift,X,Y);

  MouseX:=X;
  MouseY:=Y;

  if Button = mbLeft then
  begin
    if not CPMatch then DoPan(0,0) else DoMouse(X,Y);
    case FMode of
      gmMove: DoMove(0,0);
      gmInsert: if CPMatch then
                begin
                  GetPoint(CPCurve,CPIndex,CPx,CPy);
                  CPx:=XAxis.Value(X - Positions.XAxisLeft);
                  CPy:=YAxis.Value(Height - Y - Positions.YAxisBottom);
                  InsertPoint(CPCurve,CPIndex,CPx,CPy);
                  Paint;
                end;
      gmDelete: if CPMatch then
                begin
                  DeletePoint(CPCurve,CPIndex);
                  Paint;
                end;
      gmCursor: SetMeasureCursor(X,Y);
    end;
  end
  else if Button = mbRight then
  begin
    Cx:=FXAxis.GetCenter;
    Cy:=FYAxis.GetCenter;
    Dx:=FXAxis.Value(X - Positions.XAxisLeft);
    Dy:=FYAxis.Value(Height - Y - Positions.YAxisBottom);
    if Cx > Dx then Fx:=(Cx - Dx) / 10 else Fx:=(Dx - Cx) / 10;
    if Cy > Dy then Fy:=(Cy - Dy) / 10 else Fy:=(Dy - Cy) / 10;
    for N:=1 to 10 do
    begin
      if Cx > Dx then FXAxis.SetCenter(Cx - N * Fx)
        else FXAxis.SetCenter(Cx + N * Fx);
      if Cy > Dy then FYAxis.SetCenter(Cy - N * Fy)
        else FYAxis.SetCenter(Cy + N * Fy);
      Paint;
    end;
    DoZoom(0,0);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.MouseMove(Shift: TShiftState; X,Y: Integer);
var
  Dx,Dy: Integer;
begin
  inherited MouseMove(Shift,X,Y);

  Dx:=X - MouseX;
  Dy:=Y - MouseY;

  Freeze:=ssShift in Shift;

  if ssLeft in Shift then
  begin
    if not CPMatch then DoPan(Dx,Dy);
    case FMode of
      gmMove: DoMove(Dx,Dy);
      gmCursor: DoMeasureCursor(X,Y);
    end;
  end
  else if ssRight in Shift then DoZoom(Dx,Dy)
  else
  begin
    if (FMode <> gmNone) and (FMode <> gmCursor) then DoCheckCP(X,Y);
    if FMode = gmCursor then DoMeasureCursor(X,Y)
    else if (FMode = gmNone) and (LastCPIndex > -1) then DoCheckCP(MaxInt,MaxInt)
    else if not CPMatch then DoMouse(X,Y);
  end;

  if not PanCurves and (FMode = gmMove) then SetEditEnable(CPMatch)
    else if PanCurves then SetEditEnable(True);

  MouseX:=X;
  MouseY:=Y;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.MouseUp(Button: TMouseButton; Shift: TShiftState; X,Y: Integer);
begin
  inherited MouseUp(Button,Shift,X,Y);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetGraphTitle(const Value: Str32);
begin
  if Value <> FGraphTitle then
  begin
    FGraphTitle:=Value;
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.Reset;
begin
  FXAxis.FZoom:=1.0;
  FYAxis.FZoom:=1.0;
  FXAxis.FPan:=0;
  FYAxis.FPan:=0;
  FXAxis.FMin:=FXAxis.FMinSave;
  FXAxis.FMax:=FXAxis.FMaxSave;
  FYAxis.FMin:=FYAxis.FMinSave;
  FYAxis.FMax:=FYAxis.FMaxSave;
  FXAxis.CalcAxis;
  FYAxis.CalcAxis;
  Zoom:=ZoomSave;
  Paint;
end;
{------------------------------------------------------------------------------}

function TXYGraph.MakeCurve(const AName: Str32; AColor: TColor; ALineWidth: Byte;
                            APenStyle: TPenStyle; AEnabled: Boolean): Integer;
var
  H,N: Integer;
  S: Str32;
begin
  N:=0;
  S:=AName;
  while GetCurveHandle(S,H) do
  begin
    Inc(N);
    S:=AName + IntToStr(N);
  end;
  FCurve:=TCurve.Create;
  FCurve.Name:=S;
  FCurve.Color:=AColor;
  FCurve.LineWidth:=ALineWidth;
  FCurve.PenStyle:=APenStyle;
  FCurve.Enabled:=AEnabled;
  FCurveList.Add(FCurve);
  Result:=FCurveList.IndexOf(FCurve);
  if Assigned(FControls.FViewListBox) then
  begin
    FControls.FViewListBox.Items.Add(S);
    FControls.FViewListBox.Checked[Pred(FControls.FViewListBox.Items.Count)]:=AEnabled;
  end;
  if Assigned(FControls.FPanListBox) then
  begin
    FControls.FPanListBox.Items.Add(S);
    FControls.FPanListBox.Checked[Pred(FControls.FPanListBox.Items.Count)]:=False;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DeleteCurve(AItem: Integer);
begin
  if AItem < FCurveList.Count then
  begin
    FCurve:=FCurveList.Items[AItem];
    FCurveList.Delete(AItem);
    FCurve.Destroy;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.GetCurveHandle(AName: Str32; var H: Integer): Boolean;
var
  I,J: Integer;
begin
  H:=-1;
  J:=FCurveList.Count;
  I:=0;
  AName:=AnsiUpperCase(AName);
  while I < J do
  begin
    FCurve:=FCurveList.Items[I];
    if AnsiUpperCase(FCurve.Name) = AName then
    begin
      H:=I;
      Break;
    end;
    Inc(I);
  end;
  Result:=I < J;
end;
{------------------------------------------------------------------------------}

function TXYGraph.GetCurveName(H: Integer): Str32;
begin
  Result:='';
  if (H < 0) or (H > Pred(FCurveList.Count)) then Exit;
  FCurve:=FCurveList.Items[H];
  Result:=FCurve.Name;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ChangePoint(AIndex,APosition: Integer; X,Y: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    if APosition < FCurve.FPoints.Count then FCurve.ChangePoint(APosition,X,Y);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.GetPoint(AIndex,APosition: Integer; var X,Y: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    if InRange(APosition,0,Pred(FCurve.FPoints.Count)) then
      FCurve.GetPoint(APosition,X,Y);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.AddPoint(AIndex: Integer; X,Y: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.AddPoint(X,Y);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.AddMark(AIndex,APosition: Integer; AMarkType: TMarkType; AColor: TColor);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.AddMark(APosition,AMarkType,AColor);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetMarkSize(AIndex: Integer; AMarkSize: TMarkSize);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.FMarkSize:=AMarkSize;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.AddText(AIndex,APosition,AXOfs,AYOfs: Integer; const AText: Str32; AColor: TColor);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.AddText(APosition,AXOfs,AYOfs,AText,AColor);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetCurveFont(AIndex: Integer; AName: TFontName; ASize: Integer; AStyle: TFontStyles);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.FFont.Name:=AName;
    FCurve.FFont.Size:=ASize;
    FCurve.FFont.Style:=AStyle;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.InsertPoint(AIndex,APosition: Integer; X,Y: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.InsertPoint(APosition,X,Y);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DeletePoint(AIndex,APosition: Integer);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.DeletePoint(APosition);
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetXOfs(AIndex: Integer; AOfs: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.XOfs:=AOfs;
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.GetXOfs(AIndex: Integer): TFloat;
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    Result:=FCurve.XOfs;
  end
  else Result:=0;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetYOfs(AIndex: Integer; AOfs: TFloat);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.YOfs:=AOfs;
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.GetYOfs(AIndex: Integer): TFloat;
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    Result:=FCurve.YOfs;
  end
  else Result:=0;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetCurveEnabled(AIndex: Integer; Value: Boolean);
begin
  if InRange(AIndex,0,Pred(FCurveList.Count)) then
  begin
    FCurve:=FCurveList.Items[AIndex];
    FCurve.Enabled:=Value;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.SetZoom(Value: TFloat);
begin
  if (Value <= FMaxZoom) and (Value >= 1 / FMaxZoom) then
  begin
    FZoom:=Value;
    XAxis.SetZoom(FZoom);
    YAxis.SetZoom(FZoom);
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ClearMarkBox;
begin
  if Assigned(CPBmp) then
  begin
    Canvas.CopyRect(CPRect,CPBmp.Canvas,Rect(0,0,8,8));
    CPBmp.Free;
    CPBmp:=nil;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DrawMarkBox;
var
  I,J: Integer;
begin
  if Assigned(CPBmp) then ClearMarkBox;
  I:=FPositions.FXAxisLeft + FXAxis.Pixel(CPx);
  J:=Height - Positions.YAxisBottom - FYAxis.Pixel(CPy);
  CPRect:=Rect(I - 3,J - 3,I + 4,J + 4);
  CPBmp:=TBitMap.Create;
  CPBmp.Width:=8;
  CPBmp.Height:=8;
  CPBmp.Canvas.CopyRect(Rect(0,0,8,8),Canvas,CPRect);
  Canvas.Pen.Color:=clWhite;
  Canvas.Brush.Color:=clWhite;
  HClip:=CreateRectRgn(Positions.XAxisLeft,Positions.YAxisTop,
                       Width - Positions.XAxisRight,Height - Positions.YAxisBottom);
  SelectClipRgn(Canvas.Handle,HClip);

  if FMode = gmCursor then
  begin
    Canvas.MoveTo(CPRect.Left + 1,CPRect.Top + 1);
    Canvas.LineTo(CPRect.Right,CPRect.Bottom);
    Canvas.MoveTo(CPRect.Right - 1,CPRect.Top + 1);
    Canvas.LineTo(CPRect.Left,CPRect.Bottom);
  end
  else Canvas.FrameRect(CPRect);

  DeleteObject(HClip);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DrawMark(ACanvas: TCanvas; MarkType: TMarkType;
                            MarkColor: TColor; MarkSize: TMarkSize; X,Y: Integer);
begin
  ACanvas.Pen.Color:=MarkColor;
  ACanvas.Brush.Style:=bsClear;
  case MarkType of
    mtBox: begin
             ACanvas.MoveTo(X - MarkSize,Y - MarkSize);
             ACanvas.LineTo(X + MarkSize,Y - MarkSize);
             ACanvas.LineTo(X + MarkSize,Y + MarkSize);
             ACanvas.LineTo(X - MarkSize,Y + MarkSize);
             ACanvas.LineTo(X - MarkSize,Y - MarkSize);
           end;
    mtCircle: ACanvas.Ellipse(X - MarkSize,Y - MarkSize,X + MarkSize + 2,Y + MarkSize + 2);
    mtCross: begin
               ACanvas.MoveTo(X - MarkSize + 1,Y - MarkSize + 1);
               ACanvas.LineTo(X + MarkSize,Y + MarkSize);
               ACanvas.MoveTo(X + MarkSize - 1,Y - MarkSize + 1);
               ACanvas.LineTo(X - MarkSize,Y + MarkSize);
             end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.CheckCurvePoints(X,Y: Integer);
var
  I,J,K,L: Integer;
  Px,Py,Lx,Ly,Dx,Dy,MaxXDif,MaxYDif: TFloat;
begin
  ClearMarkBox;
  if not Freeze or (Freeze and not CPMatch) then
  begin
    Px:=FXAxis.Value(X);
    Py:=FYAxis.Value(Y);

    MaxXDif:=10 * FXAxis.FValuePerPixel;
    MaxYDif:=10 * FYAxis.FValuePerPixel;

    CPMatch:=False;
    J:=Pred(FCurveList.Count);
    for I:=0 to J do
    begin
      FCurve:=FCurveList.Items[I];
      if FCurve.FEnabled then
      begin
        K:=Pred(FCurve.FPoints.Count);
        for L:=0 to K do
        begin
          GetPoint(I,L,Lx,Ly);
          Dx:=Abs(Px - Lx);
          Dy:=Abs(Py - Ly);
          if not CPMatch then
          begin
            CPMatch:=(Dx < MaxXDif) and (Dy < MaxYDif);
            if CPMatch then
            begin
              CPx:=Lx;
              CPy:=Ly;
              CPCurve:=I;
              CPIndex:=L;
            end;
          end
          else
          begin
            if (Dx < Abs(Px - CPx)) and (Dy < MaxYDif) or
               (Dy < Abs(Py - CPy)) and (Dx < MaxXDif) then
            begin
              CPx:=Lx;
              CPy:=Ly;
              CPCurve:=I;
              CPIndex:=L;
            end;
          end;
        end;
      end;
    end;
  end;
  if CPMatch then DrawMarkBox;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ShowHintPanel(Show: Boolean);
begin
  FHintPanel.Visible:=Show;
  if Assigned(FControls.FHintPanel) then FControls.FHintPanel.Checked:=Show;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ChangeCPx(Fx: TFloat);
begin
  if (FMode = gmMove) and CPMatch then
  begin
    GetPoint(CPCurve,CPIndex,CPx,CPy);
    ChangePoint(CPCurve,CPIndex,Fx,CPy);
    CPx:=Fx;
    OutXY(CPx,CPy);
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ChangeCPy(Fy: TFloat);
begin
  if (FMode = gmMove) and CPMatch then
  begin
    GetPoint(CPCurve,CPIndex,CPx,CPy);
    ChangePoint(CPCurve,CPIndex,CPx,Fy);
    CPy:=Fy;
    OutXY(CPx,CPy);
    Paint;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.ChangeCurveOfs(Ox,Oy: TFloat; Relative: Boolean);
var
  N: Integer;
begin
  if Assigned(FControls.FPanListBox) then
    for N:=0 to Pred(FControls.FPanListBox.Items.Count) do
  begin
    if FControls.FPanListBox.Checked[N] then
    begin
      FCurve:=FCurveList.Items[N];
      if FCurve.FEnabled then
      begin
        if Relative then
        begin
          if Ox > -9.99E15 then SetXOfs(N,GetXOfs(N) + Ox);
          if Oy > -9.99E15 then SetYOfs(N,GetYOfs(N) + Oy);
        end
        else
        begin
          if Ox > -9.99E15 then SetXOfs(N,Ox);
          if Oy > -9.99E15 then SetYOfs(N,Oy);
        end;
        OutXY(GetXOfs(N),GetYOfs(N));
      end;
    end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.GetCPInfo(var CPMatch: Boolean; var CPCurve,CPIndex: Integer);
begin
  CPMatch:=CPMatch;
  CPCurve:=CPCurve;
  CPIndex:=CPIndex;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoXEditExit(Sender: TObject);
var
  F: TFloat;
begin
  if not AtoF(TEdit(FControls.FXIn).Text,F) then Exit;
  ChangeCPx(F);
  ChangeCurveOfs(F,-9.9E16,False);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoYEditExit(Sender: TObject);
var
  F: TFloat;
begin
  if not AtoF(TEdit(FControls.FYIn).Text,F) then Exit;
  ChangeCPy(F);
  ChangeCurveOfs(-9.9E16,F,False);
end;
{------------------------------------------------------------------------------}

{ THintPanel }

constructor THintPanel.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Graph:=TXYGraph(AOwner);
  FStrings:=TStringList.Create;
  FStrings.OnChange:=DoStringsChange;
  SetBounds(5,5,0,0);
  Cursor:=crHandPoint;
  Moving:=False;
  Start:=True;
end;
{------------------------------------------------------------------------------}

destructor THintPanel.Destroy;
begin
  FStrings.Free;
  inherited Destroy;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.Loaded;
begin
  inherited Loaded;
  Canvas.Font.Name:='MS Sans Serif';
  Canvas.Font.Size:=8;
  Canvas.Font.Color:=clBlack;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.NewBounds;
var
  H,I,J,L,N,W: Integer;
begin
  J:=0;
  N:=0;
  if FStrings.Count > 0 then
  begin
    for I:=0 to Pred(FStrings.Count) do
    begin
      L:=Canvas.TextWidth(FStrings.Strings[I]);
      if L > J then J:=L;
      if Length(FStrings.Strings[I]) > 0 then Inc(N);
    end;

    H:=14 * N + 4;
    W:=J + 4;

    if (N > 0) and (N <= MaxHintLines) then
    begin
      Width:=W + 4;
      Height:=H;
    end;
  end;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.DoStringsChange(Sender: TObject);
begin
  NewBounds;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.MouseDown(Button: TMouseButton; Shift: TShiftState; X,Y: Integer);
begin
  inherited MouseDown(Button,Shift,X,Y);
  Anchors:=[];
  MouseX:=X;
  MouseY:=Y;
  Graph.ClearMarkBox;
  Graph.CPMatch:=False;
  Moving:=True;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.MouseMove(Shift: TShiftState; X,Y: Integer);
var
  Dx,Dy: Integer;
begin
  inherited MouseMove(Shift,X,Y);
  if ssLeft in Shift then
  begin
    Dx:=X - MouseX;
    Dy:=Y - MouseY;
    SetBounds(Left + Dx,Top + Dy,Width,Height);
  end;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.MouseUp(Button: TMouseButton; Shift: TShiftState; X,Y: Integer);
begin
  inherited MouseUp(Button,Shift,X,Y);
  Anchors:=[akRight,akTop];
  Moving:=False;
end;
{------------------------------------------------------------------------------}

procedure THintPanel.Paint;
var
  I,L,N: Integer;
begin
  inherited Paint;

  if Start then Start:=False;

  if FStrings.Count > 0 then
  begin
    N:=0;
    for I:=0 to Pred(FStrings.Count) do
    begin
      L:=Length(FStrings.Strings[I]);
      if (L > 0) and (N <= MaxHintLines) then Inc(N);
    end;

    for I:=0 to Pred(N) do Canvas.TextOut(2,2 + I * 14,FStrings.Strings[I]);
  end;
end;

procedure TXYGraph.DoButtonClick(Sender: TObject);
begin
  if Sender = FControls.FClear then
  begin
    while FCurveList.Count > 0 do DeleteCurve(0);
    FHintPanel.FStrings.Clear;
    ShowHintPanel(False);
    GraphTitle:='Graph-Title';
    if Assigned(FControls.FViewListBox) then FControls.FViewListBox.Items.Clear;
    if Assigned(FControls.FPanListBox) then FControls.FPanListBox.Items.Clear;
    Reset;
    Application.ProcessMessages;
    Paint;
  end
  else if (Sender = FControls.FOpenView) and Assigned(FControls.FViewListBox) then
  begin
    FControls.FViewListBox.BringToFront;
    FControls.FViewListBox.Visible:=not FControls.FViewListBox.Visible;
  end
  else if (Sender = FControls.FOpenPan) and Assigned(FControls.FPanListBox) then
  begin
    FControls.FPanListBox.BringToFront;
    FControls.FPanListBox.Visible:=not FControls.FPanListBox.Visible;
  end
  else if Sender = FControls.FReset then Reset;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoRadioButtonClick(Sender: TObject);
begin
  if Sender = FControls.FModeNone then FMode:=gmNone
  else if Sender = FControls.FModeMove then FMode:=gmMove
  else if Sender = FControls.FModeInsert then FMode:=gmInsert
  else if Sender = FControls.FModeDelete then FMode:=gmDelete
  else if Sender = FControls.FModeCursor then FMode:=gmCursor;
  SetEditEnable(FMode = gmMove);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoCheckBoxClick(Sender: TObject);
begin
  if Sender = FControls.FAspectRatio then
    ZoomAspectRatio:=FControls.FAspectRatio.Checked
  else if Sender = FControls.FMainGrid then
  begin
    FXAxis.ShowMainGrid:=FControls.FMainGrid.Checked;
    FYAxis.ShowMainGrid:=FControls.FMainGrid.Checked;
  end
  else if Sender = FControls.FSubGrid then
  begin
    FXAxis.ShowSubGrid:=FControls.FSubGrid.Checked;
    FYAxis.ShowSubGrid:=FControls.FSubGrid.Checked;
  end
  else if Sender = FControls.FHintPanel then
    FHintPanel.Visible:=FControls.FHintPanel.Checked;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DoListBoxClickCheck(Sender: TObject);
var
  LB: TCheckListBox;
  N: Integer;

begin
  if Sender = FControls.FViewListBox then
  begin
    LB:=FControls.FViewListBox;
    for N:=0 to Pred(LB.Items.Count) do
    begin
      FCurve:=FCurveList.Items[N];
      FCurve.Enabled:=LB.Checked[N];
    end;
    Paint;
  end
  else if Sender = FControls.FPanListBox then
  begin
    PanCurves:=False;
    N:=0;
    if Assigned(FControls.FPanListBox) then
      while not PanCurves and (N < FControls.FPanListBox.Items.Count) do
    begin
      PanCurves:=FControls.FPanListBox.Checked[N];
      Inc(N);
    end;
    if FMode <> gmMove then SetEditEnable(PanCurves);
  end;
end;

procedure TXYGraph.SetMode(Value: TMode);
begin
  FMode:=Value;
  case FMode of
    gmNone: if Assigned(FControls.FModeNone) then
              FControls.FModeNone.Checked:=True;
    gmMove: if Assigned(FControls.FModeMove) then
              FControls.FModeMove.Checked:=True;
    gmInsert: if Assigned(FControls.FModeInsert) then
                FControls.FModeInsert.Checked:=True;
    gmDelete: if Assigned(FControls.FModeDelete) then
                FControls.FModeDelete.Checked:=True;
    gmCursor: if Assigned(FControls.FModeCursor) then
                FControls.FModeCursor.Checked:=True;
  end;
end;

{ TControls }

constructor TControls.Create(AGraph: TXYGraph);
begin
  inherited Create;
  Graph:=AGraph;
  FXOut:=nil;
  FYOut:=nil;
  FMode:=nil;
  FCurve:=nil;
  FItem:=nil;
  FColor:=nil;
  FAngle:=nil;
  FXIn:=nil;
  FYIn:=nil;
  FClear:=nil;
  FOpenView:=nil;
  FOpenPan:=nil;
  FReset:=nil;
  FModeNone:=nil;
  FModeMove:=nil;
  FModeInsert:=nil;
  FModeDelete:=nil;
  FModeCursor:=nil;
  FAspectRatio:=nil;
  FMainGrid:=nil;
  FSubGrid:=nil;
  FHintPanel:=nil;
  FViewListBox:=nil;
  FPanListBox:=nil;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetControl(Index: Integer; Value: TControl);
begin
  case Index of
    0: FXOut:=Value;
    1: FYOut:=Value;
    2: FMode:=Value;
    3: FCurve:=Value;
    4: FItem:=Value;
    5: FColor:=Value;
    6: FAngle:=Value;
  end;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetEdit(Index: Integer; Value: TEdit);
begin
  case Index of
    0: begin
         FXIn:=Value;
         if Assigned(FXIn) then FXIn.OnExit:=Graph.DoXEditExit;
       end;
    1: begin
         FYIn:=Value;
         if Assigned(FYIn) then FYIn.OnExit:=Graph.DoYEditExit;
       end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetButton(Index: Integer; Value: TButton);
begin
  case Index of
    0: begin
         FClear:=Value;
         if Assigned(FClear) then FClear.OnClick:=Graph.DoButtonClick;
       end;
    1: begin
         begin
           FOpenView:=Value;
           if Assigned(FOpenView) then FOpenView.OnClick:=Graph.DoButtonClick;
         end;
       end;
    2: begin
         FOpenPan:=Value;
         if Assigned(FOpenPan) then FOpenPan.OnClick:=Graph.DoButtonClick;
       end;
    3: begin
         FReset:=Value;
         if Assigned(FReset) then FReset.OnClick:=Graph.DoButtonClick;
       end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetRadioButton(Index: Integer; Value: TRadioButton);
begin
  case Index of
    0: begin
         FModeNone:=Value;
         if Assigned(FModeNone) then
           FModeNone.OnClick:=Graph.DoRadioButtonClick;
       end;
    1: begin
         FModeMove:=Value;
         if Assigned(FModeMove) then
           FModeMove.OnClick:=Graph.DoRadioButtonClick;
       end;
    2: begin
         FModeInsert:=Value;
         if Assigned(FModeInsert) then
           FModeInsert.OnClick:=Graph.DoRadioButtonClick;
       end;
    3: begin
         FModeDelete:=Value;
         if Assigned(FModeDelete) then
           FModeDelete.OnClick:=Graph.DoRadioButtonClick;
       end;
    4: begin
         FModeCursor:=Value;
         if Assigned(FModeCursor) then
           FModeCursor.OnClick:=Graph.DoRadioButtonClick;
       end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetCheckBox(Index: Integer; Value: TCheckBox);
begin
  case Index of
    0: begin
         FAspectRatio:=Value;
         if Assigned(FAspectRatio) then
           FAspectRatio.OnClick:=Graph.DoCheckBoxClick;
       end;
    1: begin
         FMainGrid:=Value;
         if Assigned(FMainGrid) then
           FMainGrid.OnClick:=Graph.DoCheckBoxClick;
       end;
    2: begin
         FSubGrid:=Value;
         if Assigned(FSubGrid) then
           FSubGrid.OnClick:=Graph.DoCheckBoxClick;
       end;
    3: begin
         FHintPanel:=Value;
         if Assigned(FHintPanel) then
           FHintPanel.OnClick:=Graph.DoCheckBoxClick;
       end;
  end;
end;
{------------------------------------------------------------------------------}

procedure TControls.SetListBox(Index: Integer; Value: TCheckListBox);
begin
  case Index of
    0: begin
         FViewListBox:=Value;
         if Assigned(FViewListBox) then
           FViewListBox.OnClickCheck:=Graph.DoListBoxClickCheck;
       end;
    1: begin
         FPanListBox:=Value;
         if Assigned(FPanListBox) then
           FPanListBox.OnClickCheck:=Graph.DoListBoxClickCheck;
       end;
  end;
end;

function TXYGraph.SaveCurveToStream(FileStream: TFileStream; Item: Integer): Boolean;
var
  CurveData: TCurveData;
  N: Integer;
begin
  Result:=False;
  if not InRange(Item,0,Pred(FCurveList.Count)) or not Assigned(FileStream) then Exit;
  FCurve:=FCurveList.Items[Item];
  try
    CurveData.Name:=FCurve.Name;
    CurveData.Enabled:=FCurve.Enabled;
    CurveData.Color:=FCurve.Color;
    CurveData.LineWidth:=FCurve.LineWidth;
    CurveData.PenStyle:=FCurve.PenStyle;
    CurveData.Points:=FCurve.FPoints.Count;
    CurveData.Texts:=FCurve.FTexts.Count;
    CurveData.Marks:=FCurve.FMarks.Count;
    CurveData.XOfs:=FCurve.XOfs;
    CurveData.YOfs:=FCurve.YOfs;
    CurveData.FontName:=FCurve.FFont.Name;
    CurveData.FontSize:=FCurve.FFont.Size;
    CurveData.FontStyle:=FCurve.FFont.Style;
    CurveData.MarkSize:=FCurve.MarkSize;

    FileStream.Write(CurveData,SizeOf(TCurveData));

    for N:=0 to Pred(FCurve.FPoints.Count) do
      FileStream.Write(FCurve.FPoints.Items[N]^,SizeOf(TPointRec));

    for N:=0 to Pred(FCurve.FTexts.Count) do
      FileStream.Write(FCurve.FTexts.Items[N]^,SizeOf(TTextRec));

    for N:=0 to Pred(FCurve.FMarks.Count) do
      FileStream.Write(FCurve.FMarks.Items[N]^,SizeOf(TMarkRec));

    Result:=True;
  except
    ShowMessage('Error writing stream!');
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.LoadCurveFromStream(FileStream: TFileStream): Boolean;
var
  CurveData: TCurveData;
  PointRec: TPointRec;
  TextRec: TTextRec;
  MarkRec: TMarkRec;
  H,N: Integer;
begin
  Result:=False;
  if not Assigned(FileStream) then Exit;
  try
    FileStream.Read(CurveData,SizeOf(TCurveData));
    H:=MakeCurve(CurveData.Name,CurveData.Color,CurveData.LineWidth,
                 CurveData.PenStyle,CurveData.Enabled);
    SetXOfs(H,CurveData.XOfs);
    SetYOfs(H,CurveData.YOfs);
    SetCurveFont(H,CurveData.FontName,CurveData.FontSize,CurveData.FontStyle);
    SetMarkSize(H,CurveData.MarkSize);

    for N:=0 to Pred(CurveData.Points) do
    begin
      FileStream.Read(PointRec,SizeOf(TPointRec));
      AddPoint(H,PointRec.x,PointRec.y);
    end;

    for N:=0 to Pred(CurveData.Texts) do
    begin
      FileStream.Read(TextRec,SizeOf(TTextRec));
      AddText(H,TextRec.PointIndex,TextRec.XOfs,TextRec.YOfs,
              TextRec.Text,TextRec.TextColor);
    end;

    for N:=0 to Pred(CurveData.Marks) do
    begin
      FileStream.Read(MarkRec,SizeOf(TMarkRec));
      AddMark(H,MarkRec.PointIndex,MarkRec.MarkType,MarkRec.MarkColor);
    end;

    Result:=True;
  except
    ShowMessage('Error reading stream!');
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.SaveCurveToFile(const FileName: string; Item: Integer): Boolean;
var
  FileStream: TFileStream;
begin
  Result:=False;
  try
    FileStream:=TFileStream.Create(FileName,fmCreate);
    try
      FileStream.Position:=0;
      Result:=SaveCurveToStream(FileStream,Item);
    except
      Result:=False;
    end;
  finally
    FileStream.Free;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.LoadCurveFromFile(const FileName: string): Boolean;
var
  FileStream: TFileStream;
begin
  Result:=False;
  if not FileExists(FileName) then Exit;
  try
    FileStream:=TFileStream.Create(FileName,fmOpenRead);
    try
      FileStream.Position:=0;
      Result:=LoadCurveFromStream(FileStream);
    except
      Result:=False;
    end;
  finally
    FileStream.Free;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.SaveGraphToFile(const FileName: string): Boolean;
var
  FileStream: TFileStream;
  GraphData: TGraphData;
  FontRec: TFontRec;
  N: Integer;
begin
  Result:=False;
  try
    FileStream:=TFileStream.Create(FileName,fmCreate);
    try
      GraphData.GraphTitle:=FGraphTitle;
      GraphData.Curves:=FCurveList.Count;
      GraphData.Zoom:=FZoom;
      GraphData.MaxZoom:=FMaxZoom;
      FileStream.Position:=0;
      FileStream.Write(GraphData,SizeOf(GraphData));
      FileStream.Write(FXAxis.FTitle,FXAxis.InstanceSize);
      FileStream.Write(FYAxis.FTitle,FYAxis.InstanceSize);
      FileStream.Write(FColors.FAxisBkGnd,FColors.InstanceSize);
      FileStream.Write(FPositions.FXAxisLeft,FPositions.InstanceSize);

      FontRec.AxisScaleFontName:=FFonts.FAxisScale.Name;
      FontRec.AxisScaleFontSize:=FFonts.FAxisScale.Size;
      FontRec.AxisScaleFontStyle:=FFonts.FAxisScale.Style;
      FontRec.AxisTitleFontName:=FFonts.FAxisTitle.Name;
      FontRec.AxisTitleFontSize:=FFonts.FAxisTitle.Size;
      FontRec.AxisTitleFontStyle:=FFonts.FAxisTitle.Style;
      FontRec.GraphTitleFontName:=FFonts.FGraphTitle.Name;
      FontRec.GraphTitleFontSize:=FFonts.FGraphTitle.Size;
      FontRec.GraphTitleFontStyle:=FFonts.FGraphTitle.Style;
      FileStream.Write(FontRec,SizeOf(FontRec));

      for N:=0 to Pred(GraphData.Curves) do SaveCurveToStream(FileStream,N);
      FHintPanel.FStrings.SaveToStream(FileStream);
      Result:=True;
    except
      Result:=False;
    end;
  finally
    FileStream.Free;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.LoadGraphFromFile(const FileName: string): Boolean;
var
  FileStream: TFileStream;
  GraphData: TGraphData;
  FontRec: TFontRec;
  N: Integer;
begin
  Result:=False;
  if not FileExists(FileName) then Exit;
  try
    FileStream:=TFileStream.Create(FileName,fmOpenRead);
    try
      FileStream.Position:=0;
      FileStream.Read(GraphData,SizeOf(GraphData));
      FGraphTitle:=GraphData.GraphTitle;
      FZoom:=GraphData.Zoom;
      FMaxZoom:=GraphData.MaxZoom;
      FileStream.Read(FXAxis.FTitle,FXAxis.InstanceSize);
      FileStream.Read(FYAxis.FTitle,FYAxis.InstanceSize);
      FileStream.Read(FColors.FAxisBkGnd,FColors.InstanceSize);
      FileStream.Read(FPositions.FXAxisLeft,FPositions.InstanceSize);

      FileStream.Read(FontRec,SizeOf(FontRec));
      FFonts.FAxisScale.Name:=FontRec.AxisScaleFontName;
      FFonts.FAxisScale.Size:=FontRec.AxisScaleFontSize;
      FFonts.FAxisScale.Style:=FontRec.AxisScaleFontStyle;
      FFonts.FAxisTitle.Name:=FontRec.AxisTitleFontName;
      FFonts.FAxisTitle.Size:=FontRec.AxisTitleFontSize;
      FFonts.FAxisTitle.Style:=FontRec.AxisTitleFontStyle;
      FFonts.FGraphTitle.Name:=FontRec.GraphTitleFontName;
      FFonts.FGraphTitle.Size:=FontRec.GraphTitleFontSize;
      FFonts.FGraphTitle.Style:=FontRec.GraphTitleFontStyle;

      for N:=0 to Pred(GraphData.Curves) do LoadCurveFromStream(FileStream);
      FHintPanel.FStrings.LoadFromStream(FileStream);
      FXAxis.CalcAxis;
      FYAxis.CalcAxis;
      FHintPanel.Paint;
      Paint;
      Result:=True;
    except
      Result:=False;
    end;
  finally
    FileStream.Free;
  end;
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DXFAxis;
var
  Dif,MainStep,SubStep: TFloat;
  TickLen,TextWidth: TFloat;
  N,M: Integer;
  S: Str32;
begin
  if not Assigned(DXFOut) then Exit;
  TextWidth:=DXFOut.TextHeight / 4 * 3;
  TickLen:=5;
  Dif:=FXAxis.FMax - FXAxis.FMin;
  if FXAxis.MainTicks <> 0 then MainStep:=Dif / FXAxis.MainTicks else MainStep:=Dif;
  if FXAxis.SubTicks <> 0 then SubStep:=MainStep / FXAxis.SubTicks else SubStep:=MainStep;
  for N:=0 to FXAxis.MainTicks do
  begin
    DXFOut.Line(DXFOut.ToX(FXAxis.FMin + N * MainStep),
                DXFOut.ToY(FYAxis.FMin) - TickLen,0,
                DXFOut.ToX(FXAxis.FMin + N * MainStep),
                DXFOut.ToY(FYAxis.FMax),0);
    S:=FloatToStrF(FXAxis.Min + (N * FXAxis.ValuePerMainTick),
                   ffFixed,7,FXAxis.Decimals);
    for M:=1 to Length(S) do if S[M] = ' ' then Delete(S,M,1);
    DXFOut.DText(DXFOut.ToX(FXAxis.FMin + N * MainStep) - TextWidth * Length(S) / 2,
                 DXFOut.ToY(FYAxis.FMin) - DXFOut.TextHeight - TickLen - 1,0,
                 DXFOut.TextHeight,0,S);
    if FXAxis.FShowSubGrid and (N < FXAxis.MainTicks) then
      for M:=1 to Pred(FXAxis.SubTicks) do
    begin
      DXFOut.Line(DXFOut.ToX(FXAxis.FMin + N * MainStep + M * SubStep),
                  DXFOut.ToY(FYAxis.FMin),0,
                  DXFOut.ToX(FXAxis.FMin + N * MainStep + M * SubStep),
                  DXFOut.ToY(FYAxis.FMax),0);
    end;
  end;

  Dif:=FYAxis.FMax - FYAxis.FMin;
  if FYAxis.MainTicks <> 0 then MainStep:=Dif / FYAxis.MainTicks else MainStep:=Dif;
  if FYAxis.SubTicks <> 0 then SubStep:=MainStep / FYAxis.SubTicks else SubStep:=MainStep;
  for N:=0 to FYAxis.MainTicks do
  begin
    DXFOut.Line(DXFOut.ToX(FXAxis.FMin) - TickLen,
                DXFOut.ToY(FYAxis.FMin + N * MainStep),0,
                DXFOut.ToX(FXAxis.FMax),
                DXFOut.ToY(FYAxis.FMin + N * MainStep),0);
    S:=FloatToStrF(FYAxis.Min + (N * FYAxis.ValuePerMainTick),
                   ffFixed,7,FYAxis.Decimals);
    for M:=1 to Length(S) do if S[M] = ' ' then Delete(S,M,1);
    DXFOut.DText(DXFOut.ToX(FXAxis.FMin) - TickLen - TextWidth * Length(S) - 1,
                 DXFOut.ToY(FYAxis.FMin + N * MainStep) - DXFOut.TextHeight / 2,
                 0,DXFOut.TextHeight,0,S);
    if FXAxis.FShowSubGrid and (N < FYAxis.MainTicks) then
      for M:=1 to Pred(FYAxis.SubTicks) do
    begin
      DXFOut.Line(DXFOut.ToX(FXAxis.FMin),
                  DXFOut.ToY(FYAxis.FMin + N * MainStep + M * SubStep),0,
                  DXFOut.ToX(FXAxis.FMax),
                  DXFOut.ToY(FYAxis.FMin + N * MainStep + M * SubStep),0);
    end;
  end;

  S:=FXAxis.FTitle;
  SubStep:=Length(S) * TextWidth;
  MainStep:=(FXAxis.FMax - FXAxis.FMin) / 2;
  Dif:=FXAxis.FMin + MainStep - SubStep;
  DXFOut.DText(DXFOut.ToX(Dif),
               DXFOut.ToY(FYAxis.FMin) - TickLen - DXFOut.TextHeight * 6,
               0,DXFOut.TextHeight * 2,0,S);

  S:=FYAxis.FTitle;
  SubStep:=Length(S) * TextWidth;
  MainStep:=(FYAxis.FMax - FYAxis.FMin) / 2;
  Dif:=FYAxis.FMin + MainStep - SubStep;
  DXFOut.DText(DXFOut.ToX(FXAxis.FMin) - TickLen - TextWidth * Length(S) -
               DXFOut.TextHeight * 2 - 2,
               DXFOut.ToY(Dif),0,DXFOut.TextHeight * 2,90,S);

  S:=FGraphTitle;
  SubStep:=Length(S) * TextWidth;
  MainStep:=(FXAxis.FMax - FXAxis.FMin) / 2;
  Dif:=FXAxis.FMin + MainStep - SubStep;
  DXFOut.DText(DXFOut.ToX(Dif),
               DXFOut.ToY(FYAxis.FMax) + DXFOut.TextHeight * 6,
               0,DXFOut.TextHeight * 2,0,S);
end;
{------------------------------------------------------------------------------}

procedure TXYGraph.DXFCurves;
var
  H,I,J: Integer;
  X,Y: TFloat;
begin
  for H:=0 to Pred(FCurveList.Count) do
  begin
    FCurve:=FCurveList.Items[H];
    if FCurve.Enabled and (FCurve.FPoints.Count > 0) then
    begin
      J:=Pred(FCurve.FPoints.Count);
      DXFOut.StartPolyLine(False);
      for I:=0 to J do
      begin
        FCurve.GetPoint(I,X,Y);
        DXFOut.Vertex(DXFOut.ToX(X),DXFOut.ToY(Y),0);
      end;
      DXFOut.EndPolyLine;
    end;
  end;
end;
{------------------------------------------------------------------------------}

function TXYGraph.MakeDXF(const FileName: string; FromX1,FromY1,FromX2,FromY2,
                          ToX1,ToY1,ToX2,ToY2,TextHeight: TFloat;
                          Decimals: Byte): Boolean;
begin
  Result:=False;
  try
    DXFOut:=TDXFOut.Create(FromX1,FromY1,FromX2,FromY2,ToX1,ToY1,ToX2,ToY2,
                           TextHeight,Decimals);
    try
      DXFOut.Header;
      DXFAxis;
      DXFCurves;
      DXFOut.Trailer;
      DXFOut.StringList.SaveToFile(FileName);
      Result:=True;
    except
      Result:=False;
    end;
  finally
    DXFOut.Free;
  end;
end;

{ TDXFOut }

constructor TDXFOut.Create(AFromXMin,AFromYMin,AFromXMax,AFromYMax,
                           AToXMin,AToYMin,AToXMax,AToYMax,ATextHeight: TFloat; ADecimals: Byte);
begin
  inherited Create;
  FromXMin:=AFromXMin;
  FromYMin:=AFromYMin;
  FromXMax:=AFromXMax;
  FromYMax:=AFromYMax;
  ToXMin:=AToXMin;
  ToYMin:=AToYMin;
  ToXMax:=AToXMax;
  ToYMax:=AToYMax;
  TextHeight:=ATextHeight;
  Decimals:=ADecimals;
  StringList:=TStringList.Create;
end;
{------------------------------------------------------------------------------}

destructor TDXFOut.Destroy;
begin
  StringList.Free;
  inherited Destroy;
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Header;
begin
  LayerName:='0';
  StringList.Add('0');
  StringList.Add('SECTION');
  StringList.Add('2');
  StringList.Add('HEADER');
  StringList.Add('9');
  StringList.Add('$LIMMIN');
  StringList.Add('10');
  StringList.Add(FToA(ToXMin));
  StringList.Add('20');
  StringList.Add(FToA(ToYMin));
  StringList.Add('9');
  StringList.Add('$LIMMAX');
  StringList.Add('10');
  StringList.Add(FToA(ToXMax));
  StringList.Add('20');
  StringList.Add(FToA(ToYMax));
  StringList.Add('0');
  StringList.Add('ENDSEC');
  StringList.Add('0');
  StringList.Add('SECTION');
  StringList.Add('2');
  StringList.Add('TABLES');
  StringList.Add('0');
  StringList.Add('TABLE');
  StringList.Add('2');
  StringList.Add('LAYER');
  StringList.Add('70');
  StringList.Add('1');
  StringList.Add('0');
  StringList.Add('LAYER');
  StringList.Add('2');
  StringList.Add('0');
  StringList.Add('70');
  StringList.Add('64');
  StringList.Add('62');
  StringList.Add('7');
  StringList.Add('6');
  StringList.Add('CONTINUOUS');
  StringList.Add('0');
  StringList.Add('ENDTAB');
  StringList.Add('0');
  StringList.Add('ENDSEC');
  StringList.Add('0');
  StringList.Add('SECTION');
  StringList.Add('2');
  StringList.Add('ENTITIES');
end;
{------------------------------------------------------------------------------}

function TDXFOut.FToA(F: TFloat): Str32;
var
  I: Integer;
begin
  Result:=FloatToStrF(F,ffFixed,16,Decimals);
  I:=Pos(',',Result);
  if I > 0 then Result[I]:='.';
end;
{------------------------------------------------------------------------------}

function TDXFOut.ToX(X: TFloat): TFloat;
var
  Factor,FromDif: TFloat;
begin
  FromDif:=FromXMax - FromXMin;
  if FromDif <> 0.0 then Factor:=(ToXMax - ToXMin) / FromDif else Factor:=1.0;
  Result:=X * Factor;
end;
{------------------------------------------------------------------------------}

function TDXFOut.ToY(Y: TFloat): TFloat;
var
  Factor,FromDif: TFloat;
begin
  FromDif:=FromYMax - FromYMin;
  if FromDif <> 0.0 then Factor:=(ToYMax - ToYMin) / FromDif else Factor:=1.0;
  Result:=Y * Factor;
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.SetLayer(const Name: Str32);
begin
  LayerName:=Name;
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Layer;
begin
  StringList.Add('8');
  StringList.Add(LayerName);
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.StartPoint(X,Y,Z: TFloat);
begin
  StringList.Add('10');
  StringList.Add(FToA(X));
  StringList.Add('20');
  StringList.Add(FToA(Y));
  StringList.Add('30');
  StringList.Add(FToA(Z));
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.EndPoint(X,Y,Z: TFloat);
begin
  StringList.Add('11');
  StringList.Add(FToA(X));
  StringList.Add('21');
  StringList.Add(FToA(Y));
  StringList.Add('31');
  StringList.Add(FToA(Z));
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.AddText(const Txt: Str32);
begin
  StringList.Add('1');
  StringList.Add(Txt);
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.StartPolyLine(Closed: Boolean);
var
  Flag : Byte;
begin
  StringList.Add('0');
  StringList.Add('POLYLINE');
  Layer;
  StringList.Add('66');
  StringList.Add('1');
  StartPoint(0,0,0);
  Flag:=8;
  if Closed then Flag:=Flag or 1;
  StringList.Add('70');
  StringList.Add(IntToStr(Flag));
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Vertex(X,Y,Z: TFloat);
var
 Flag : Byte;
begin
  StringList.Add('0');
  StringList.Add('VERTEX');
  Layer;
  StartPoint(X,Y,Z);
  StringList.Add('70');
  Flag:=32;
  StringList.Add(IntToStr(Flag));
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.EndPolyLine;
begin
  StringList.Add('0');
  StringList.Add('SEQEND');
  Layer;
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Line(X1,Y1,Z1,X2,Y2,Z2: TFloat);
begin
  StringList.Add('0');
  StringList.Add('LINE');
  Layer;
  StartPoint(X1,Y1,Z1);
  EndPoint(X2,Y2,Z2);
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Point(X,Y,Z: TFloat);
begin
  StringList.Add('0');
  StringList.Add('POINT');
  Layer;
  StartPoint(X,Y,Z);
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.DText(X,Y,Z,Height,Angle: TFloat; const Txt: Str32);
begin
  StringList.Add('0');
  StringList.Add('TEXT');
  Layer;
  StartPoint(X,Y,Z);
  StringList.Add('40');
  StringList.Add(FToA(Height));
  AddText(Txt);
  StringList.Add('50');
  StringList.Add(FToA(Angle));
end;
{------------------------------------------------------------------------------}

procedure TDXFOut.Trailer;
begin
  StringList.Add('0');
  StringList.Add('ENDSEC');
  StringList.Add('0');
  StringList.Add('EOF');
end;

procedure TXYGraph.Notification(Component: TComponent; Operation: TOperation);
begin
  inherited Notification(Component,Operation);

  if Operation = opRemove then
  begin
    if Component = FControls.FXOut then FControls.FXOut:=nil;
    if Component = FControls.FYOut then FControls.FYOut:=nil;
    if Component = FControls.FMode then FControls.FMode:=nil;
    if Component = FControls.FCurve then FControls.FCurve:=nil;
    if Component = FControls.FItem then FControls.FItem:=nil;
    if Component = FControls.FColor then FControls.FColor:=nil;
    if Component = FControls.FAngle then FControls.FAngle:=nil;
    if Component = FControls.FXIn then FControls.FXIn:=nil;
    if Component = FControls.FYIn then FControls.FYIn:=nil;
    if Component = FControls.FClear then FControls.FClear:=nil;
    if Component = FControls.FOpenView then FControls.FOpenView:=nil;
    if Component = FControls.FOpenPan then FControls.FOpenPan:=nil;
    if Component = FControls.FReset then FControls.FReset:=nil;
    if Component = FControls.FModeNone then FControls.FModeNone:=nil;
    if Component = FControls.FModeMove then FControls.FModeMove:=nil;
    if Component = FControls.FModeInsert then FControls.FModeInsert:=nil;
    if Component = FControls.FModeDelete then FControls.FModeDelete:=nil;
    if Component = FControls.FModeCursor then FControls.FModeCursor:=nil;
    if Component = FControls.FAspectRatio then FControls.FAspectRatio:=nil;
    if Component = FControls.FMainGrid then FControls.FMainGrid:=nil;
    if Component = FControls.FSubGrid then FControls.FSubGrid:=nil;
    if Component = FControls.FHintPanel then FControls.FHintPanel:=nil;
    if Component = FControls.FViewListBox then FControls.FViewListBox:=nil;
    if Component = FControls.FPanListBox then FControls.FPanListBox:=nil;
  end;
end;

{ TCurve }

procedure TCurve.AddMark(APointIndex: Integer; AMarkType: TMarkType;
  AColor: TColor);
begin
  GetMem(PMark,SizeOf(TMarkRec));
  PMark^.PointIndex:=APointIndex;
  PMark^.MarkType:=AMarkType;
  PMark^.MarkColor:=AColor;
  FMarks.Add(PMark);
end;

procedure TCurve.AddPoint(Ax, Ay: TFloat);
begin
  GetMem(PPoint,SizeOf(TPointRec));
  PPoint^.X:=Ax;
  PPoint^.Y:=Ay;
  FPoints.Add(PPoint);
end;

procedure TCurve.AddText(APointIndex, AXOfs, AYOfs: Integer;
  const AText: Str32; AColor: TColor);
begin
  GetMem(PText,SizeOf(TTextRec));
  PText^.PointIndex:=APointIndex;
  PText^.XOfs:=AXOfs;
  PText^.YOfs:=AYOfs;
  PText^.Text:=AText;
  PText^.TextColor:=AColor;
  FTexts.Add(PText);
end;

procedure TCurve.ChangePoint(AIndex: Integer; Ax, Ay: TFloat);
begin
  if InRange(AIndex,0,Pred(FPoints.Count)) then
  begin
    PPoint:=FPoints.Items[AIndex];
    PPoint^.X:=Ax - FXOfs;
    PPoint^.Y:=Ay - FYOfs;
  end;
end;

constructor TCurve.Create;
begin
  inherited Create;
  FPoints:=TList.Create;
  FTexts:=TList.Create;
  FMarks:=TList.Create;
  FFont:=TFont.Create;
  FFont.Name:='small font';
  FFont.Size:=7;
  FFont.Style:=[];
  FMarkSize:=4;
  FEnabled:=True;
  FColor:=clWhite;
  FLineWidth:=1;
  FPenStyle:=psSolid;
  FXOfs:=0.0;
  FYOfs:=0.0;
end;

procedure TCurve.DeletePoint(AIndex: Integer);
begin
  if InRange(AIndex,0,Pred(FPoints.Count)) then
  begin
    FreeMem(FPoints.Items[AIndex],SizeOf(TPointRec));
    FPoints.Delete(AIndex);
  end;
end;

destructor TCurve.Destroy;
var
  I: Integer;
begin
  for I:=0 to Pred(FPoints.Count) do FreeMem(FPoints.Items[I],SizeOf(TPointRec));
  FPoints.Free;
  for I:=0 to Pred(FTexts.Count) do FreeMem(FTexts.Items[I],SizeOf(TTextRec));
  FTexts.Free;
  for I:=0 to Pred(FMarks.Count) do FreeMem(FMarks.Items[I],SizeOf(TMarkRec));
  FMarks.Free;
  FFont.Free;
  inherited Destroy;
end;

procedure TCurve.GetPoint(AIndex: Integer; var Ax, Ay: TFloat);
begin
  if InRange(AIndex,0,Pred(FPoints.Count)) then
  begin
    PPoint:=FPoints.Items[AIndex];
    Ax:=PPoint^.X + FXOfs;
    Ay:=PPoint^.Y + FYOfs;
  end;
end;

procedure TCurve.InsertPoint(AIndex: Integer; Ax, Ay: TFloat);
begin
  if AIndex > -1 then
  begin
    GetMem(PPoint,SizeOf(TPointRec));
    PPoint^.X:=Ax;
    PPoint^.Y:=Ay;
    FPoints.Insert(AIndex,PPoint);
  end;
end;

initialization

end.