Tools.pas

unit Tools;

interface

uses
  Unit1, Graphics, Windows, Types, Forms, Classes, Unit3, Unit4,
  Controls, Unit7, Dialogs, Unit11, Menus, LevelEngine;

const
  ddx=0;
  ddy=7;
  MaxSlope=10/18;
  MaxGrassWidth=14/50;
  WheelHeight=0.85;
  StNum=4;
//
  stReady=0;
  stEdit=1;
//
  stMove=1;
  stSelRect=2;
  stTransform=3;
//
  stOnePoint=1;
  stTwoPoints=2;
//
  stMovePoint=2;

type

  TSVertex=record
    x,y:integer;
    dx,dy:integer;
    Visible:boolean;
  end;

  TTransArray=array[0..2,0..2] of TPoint;

  TCreateObjectTool=class(TTool)
    Object_:TEObject;
    constructor Create(Par:TLevel);override;
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  end;

  TCreateVertexTool=class(TTool)
  published
    constructor Create(Par:TLevel);override;
    destructor Destroy;override;
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    procedure KeyPressed(key:word);override;
    procedure Initialize;
    property  State:integer read Fstate write Setstate;
  protected
    procedure Setstate(const Value: integer);override;
  private
    Poly:TPolygon;
    EVertex:integer;
    dir:integer;
  end;

  TSelectTool=class(TTool)
  published
    constructor Create(Par:TLevel);override;
    procedure Initialize(Shift: TShiftState;nx,ny:integer);
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    procedure KeyPressed(key:word);override;
    procedure ClearSelection;
    procedure SelectAll;
    procedure SetSelState(sel:boolean);
    procedure Replace(tip:integer);
    procedure StartTransformation;
    property  State:integer read Fstate write Setstate;
  protected
    procedure Setstate(const Value: integer);override;
    function GenPoints:TTransArray;
  private
    x2,y2:integer;
    p:^TRPoint;
    Centre,VUp,VRight:TRPoint;
    im,jm:integer;
    MovingT:boolean;
    curm:boolean;
    corx,cory:double;
  end;

  TCreatePictureTool=class(TTool)
    Picture:TEPicture;
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  end;

  TZoomRectTool=class(TTool)
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  private
    x2,y2:integer;
  end;

  TCreateRectTool=class(TTool)
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  private
    x2,y2:integer;
  end;

  TCreateEllipseTool=class(TTool)
    procedure Draw;override;
    procedure KeyPressed(key:word);override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  private
    x2,y2,n:integer;
  end;

  TCutSplitTool=class(TTool)
  published
    procedure Draw;override;
    procedure KeyPressed(key:word);override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    property  State:integer read Fstate write Setstate;
  protected
    procedure Setstate(const Value: integer);override;
  private
    invert:boolean;  
    x2,y2:integer;
    pt:array[0..3] of TRPoint;
    npol1,npol2,n1,n2:integer;
  end;

  TPictureTileTool=class(TTool)
    Width,Height:integer;
    LeftToRight,TopToBottom:boolean;
    Picture:TEPicture;
    property  State:integer read Fstate write Setstate;
    procedure Draw;override;
    procedure KeyPressed(key:word);override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
  private
    tWidth,tHeight:double;
    rx,ry:double;
    Pressed:boolean;
  protected
    procedure Setstate(const Value: integer);override;
  end;

  TSplineTool=class(TTool)
  private
    Fstate: integer;
  public
    parts:integer;
    OnePolygon,DelSpline:boolean;
  published
    constructor Create(Par:TLevel);override;
    destructor Destroy;override;
    procedure Draw;override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    procedure KeyPressed(key:word);override;
//    procedure Initialize(n,tip:integer);
    property  State:integer read Fstate write Setstate;
    procedure CalculateCoef(P1,P2:TSVertex);
    function FindVertex(nx,ny:integer;out sign:integer):integer;
    procedure ProcessRightClick(nx,ny:integer);
  private
    Poly:array of TSVertex;
    cur:integer;
    signum:integer;
    ax,bx,cx,dx,ay,by,cy,dy:double;
    x2,y2:integer;
    Pressed:boolean;
  protected
    procedure Setstate(const Value: integer);override;
  end;

  TPolyOpTool=class(TTool)
    DelSource:boolean;
    procedure Draw;override;
    procedure KeyPressed(key:word);override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    property  State:integer read Fstate write Setstate;
    procedure PerformOp(or1:integer;or2:integer);
  protected
    procedure Setstate(const Value: integer);override;
  private
    n1,n2:integer;
  end;

  TGrassTool=class(TTool)
  public
    GHeight:double;
    GWidth,Smoothing,CorrectREdge:boolean;
  published
    constructor Create(Par:TLevel);override;
    procedure Draw;override;
    procedure KeyPressed(key:word);override;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);override;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);override;
    property  State:integer read Fstate write Setstate;
  protected
    procedure Setstate(const Value: integer);override;
  private
    n:integer;
  end;

implementation

uses Math, SysUtils, DXDraws, Unit6, Unit15, Unit16;

{ TCreateObjectTool }

constructor TCreateObjectTool.Create(Par: TLevel);
begin
  Inherited;
  Object_.typ:=2;
  Object_.TofF:=0;
  Object_.AnimNumber:=0;
end;

procedure TCreateObjectTool.Draw;
begin
  with Parent do begin
   Object_.Pos.x:=GetRX(x);
   Object_.Pos.y:=GetRY(y);
   DrawObject(Object_);
  end;
end;

procedure TCreateObjectTool.MouseDown(Shift: TShiftState;nx, ny: integer);
begin
  x:=nx;y:=ny;
  with Parent do begin
    Modified:=true;
    Object_.Pos.x:=GetRX(x);
    Object_.Pos.y:=GetRY(y);
    AddObject(Object_);
  end;
end;

procedure TCreateObjectTool.MouseMove(Shift: TShiftState;nx, ny: integer);
begin
  x:=nx;y:=ny;
end;

procedure TCreateObjectTool.MouseUp(Shift: TShiftState;nx, ny: integer);
begin
  x:=nx;y:=ny;
end;

{ TCreateVertexTool }

constructor TCreateVertexTool.Create(Par: TLevel);
begin
  inherited;
  state:=stReady;
  Poly.Grass:=0;
  Poly.Vertices:=nil;
  EVertex:=0;
  dir:=1;
end;

destructor TCreateVertexTool.Destroy;
begin
  KeyPressed(VK_ESCAPE);
  inherited;
end;

procedure TCreateVertexTool.Draw;
var
  Points:array of TPoint;
  i,s,e,l,ind:integer;
begin
  if state=stEdit then with Parent,DXDraw.Surface.Canvas,Poly do begin
    SetLength(Points,Length(Vertices));
    l:=Length(Vertices);
    if dir=-1 then s:=(EVertex+1) mod l else s:=EVertex;
    if dir=-1 then e:=EVertex else e:=(EVertex-1+l) mod l;
    i:=s;
    Brush.Style:=bsClear;
    Pen.Style:=psSolid;
    repeat
      ind:=(i-s+l) mod l;
      Points[ind].X:=GetOX(Vertices[i].x);
      Points[ind].Y:=GetOY(Vertices[i].y);
      i:=(i+1) mod l;
    until (i-e+l) mod l=1;
    if Grass=0 then Pen.Color:=SwapColors(Palette[lvPoly])
    else Pen.Color:=SwapColors(Palette[lvGrass]);
    Polyline(Points);
    Pen.Style:=psDot;
    MoveTo(GetOX(Vertices[e].x),GetOY(Vertices[e].y));
    LineTo(GetOX(Vertices[s].x),GetOY(Vertices[s].y));
    if HighLightVertices then begin
      Pen.Style:=psSolid;
      Pen.Color:=SwapColors(Palette[lvHighlight]);
      for i:=0 to High(Points) do
       Rectangle(Points[i].X-1,Points[i].Y-1,
         Points[i].X+2,Points[i].Y+2);
    end;
  end;
end;

procedure TCreateVertexTool.Initialize;
begin
  if state=stEdit then begin
    KeyPressed(VK_ESCAPE);
  end;
end;

procedure TCreateVertexTool.KeyPressed(key: word);
var
  l,i:integer;
  p:TPoint;
begin
  case key of
    VK_RETURN:dir:=-dir;
    VK_SPACE:if state=stEdit then with Parent do begin
      l:=Length(Poly.Vertices);
      //p:=Poly.Vertices[EVertex];
      Poly.Vertices[EVertex]:=Poly.Vertices[(EVertex+dir+l) mod l];
      //Poly.Vertices[(EVertex-dir+l) mod l]:=p;
      EVertex:=(EVertex+dir+l) mod l;
      dir:=-dir;
      p:=ALEForm.PaintBox1.ClientToScreen(Point(
      GetOX(Poly.Vertices[EVertex].x),GetOY(Poly.Vertices[EVertex].y)));
      SetCursorPos(p.x,p.y);
    end;
    VK_ESCAPE:if state=stEdit then begin
      if Length(Poly.Vertices)>3 then with Parent do begin
        for i:=EVertex to High(Poly.Vertices)-1 do
          Poly.Vertices[i]:=Poly.Vertices[i+1];
        SetLength(Poly.Vertices,High(Poly.Vertices));
        //Modified:=true;
        AddPolygon(Poly);
      end;
      SetLength(Poly.Vertices,0);
      state:=stReady;
    end;
  end;
end;

procedure TCreateVertexTool.MouseDown(Shift: TShiftState;nx, ny: integer);
var
  p:TRpoint;
  npol,n,tp,i:integer;
begin
  if state=stReady then begin
   x:=nx;y:=ny;
   with Parent do begin
    p.x:=GetRX(nx);
    p.y:=GetRY(ny);
    WhatHere(p,npol,n,tp);
    Modified:=true;
    if (tp=tpVertex) or (tp=tpPolygon) then begin
      //Finalize(Poly.Vertices);
      Poly:=Polygons[npol];
      DeletePolygon(npol);
      SetLength(Poly.Vertices,Length(Poly.Vertices)+1);
      for i:=High(Poly.Vertices) downto n+1 do
        Poly.Vertices[i]:=Poly.Vertices[i-1];
      EVertex:=n;
      Poly.Vertices[n]:=p;
      dir:=1;
    end else begin
      SetLength(Poly.Vertices,2);
      Poly.Vertices[0].x:=GetRX(nx);
      Poly.Vertices[0].y:=GetRY(ny);
      Poly.Vertices[1].x:=Poly.Vertices[0].x;
      Poly.Vertices[1].y:=Poly.Vertices[0].y;
      EVertex:=0;
      dir:=1;
      Poly.Grass:=0;
    end;
   end;                       
   state:=stEdit;
  end else begin
    SetLength(Poly.Vertices,Length(Poly.Vertices)+1);
    for i:=High(Poly.Vertices) downto EVertex+1 do
      Poly.Vertices[i]:=Poly.Vertices[i-1];
    if dir=-1 then EVertex:=(EVertex+1+Length(Poly.Vertices)) mod Length(Poly.Vertices);
  end;
end;

procedure TCreateVertexTool.MouseMove(Shift: TShiftState;nx, ny: integer);
begin
  if state=stEdit then with Parent do begin
    Poly.Vertices[EVertex].x:=GetRX(nx);
    Poly.Vertices[EVertex].y:=GetRY(ny);
    x:=nx;y:=ny;
  end;
end;

procedure TCreateVertexTool.MouseUp(Shift: TShiftState;nx, ny: integer);
begin
  //
end;

procedure TCreateVertexTool.Setstate(const Value: integer);
begin
  Inherited;
  if State=stReady then Parent.InitUndoRedoVisible
  else begin
    ALEForm.Undo.Enabled:=false;
    ALEForm.Redo.Enabled:=false;
  end;
end;

{ TSelectTool }

procedure TSelectTool.ClearSelection;
begin
  SetSelState(false);
end;

constructor TSelectTool.Create(Par: TLevel);
begin
  inherited;
  ClearSelection;
end;

procedure TSelectTool.Draw;
var
  i,j:integer;
  pts:TTransArray;

procedure DrawPoint(i,j:integer);
begin
  Parent.DXDraw.Surface.Canvas.Rectangle(
    pts[i,j].X-1,pts[i,j].Y-1,pts[i,j].X+2,pts[i,j].Y+2);
end;

procedure DrawLine(i1,j1,i2,j2:integer);
begin
  with Parent.DXDraw.Surface.Canvas do begin
    MoveTo(pts[i1,j1].X,pts[i1,j1].Y);
    LineTo(pts[i2,j2].X,pts[i2,j2].Y);
  end;
end;

begin
  with Parent,DXDraw.Surface.Canvas do begin
    Brush.Bitmap:=nil;
    Brush.Color:=Parent.SwapColors(Palette[lvVertex]);
    Pen.Style:=psClear;
    if ShowPolygons then
    for i:=0 to High(Polygons) do with Polygons[i] do
    if ShowGrass or (Polygons[i].Grass=0) then
     for j:=0 to High(Vertices) do with Vertices[j] do
      if Selected then
       FillRect(Bounds(GetOX(x)-1,GetOY(y)-1,3,3));
    if ShowObjects then
    for i:=0 to High(Objects) do with Objects[i].Pos do
     if Selected then
       FillRect(Bounds(GetOX(x)-1,GetOY(y)-1,3,3));
    if ShowPictures or Framepictures then
    for i:=0 to High(Pics) do with Pics[i].Pos do
     if Selected then
       FillRect(Bounds(GetOX(x)-1,GetOY(y)-1,3,3));
    if State=stSelRect then begin
     Pen.Style:=psSolid;
     Pen.Color:=Parent.SwapColors(Palette[lvVertex]);
     Brush.Style:=bsClear;
     Rectangle(x,y,x2,y2);
    end;
    if State=stTransform then begin
     Pen.Style:=psSolid;
     Pen.Color:=Parent.SwapColors(Palette[lvVertex]);
     Brush.Style:=bsClear;
     pts:=GenPoints;
     for i:=0 to 2 do begin
       DrawLine(0,i,2,i);
       DrawLine(i,0,i,2);
     end;
     Pen.Color:=Parent.SwapColors(Palette[lvHighlight]);
     for i:=0 to 2 do
      for j:=0 to 2 do
       DrawPoint(i,j);
    end;
  end;
end;

function TSelectTool.GenPoints: TTransArray;
var
  pts:TTransArray;
begin
  with Parent do begin
    pts[1,1]:=Point(GetOX(Centre.x),GetOY(Centre.y));
    pts[1,0]:=Point(GetOX(Centre.x+VUp.x),GetOY(Centre.y+VUp.y));
    pts[1,2]:=Point(GetOX(Centre.x-VUp.x),GetOY(Centre.y-VUp.y));
    pts[0,1]:=Point(GetOX(Centre.x+VRight.x),GetOY(Centre.y+VRight.y));
    pts[2,1]:=Point(GetOX(Centre.x-VRight.x),GetOY(Centre.y-VRight.y));
    pts[0,0]:=Point(GetOX(Centre.x+VRight.x+VUp.x),GetOY(Centre.y+VRight.y+VUp.y));
    pts[0,2]:=Point(GetOX(Centre.x+VRight.x-VUp.x),GetOY(Centre.y+VRight.y-VUp.y));
    pts[2,2]:=Point(GetOX(Centre.x-VRight.x-VUp.x),GetOY(Centre.y-VRight.y-VUp.y));
    pts[2,0]:=Point(GetOX(Centre.x-VRight.x+VUp.x),GetOY(Centre.y-VRight.y+VUp.y));
  end;
  Result:=pts;
end;

procedure TSelectTool.Initialize(Shift: TShiftState;nx,ny:integer);
var
  i,j,npol,n,tp,k:integer;
  p:TRPoint;
  p4:^TRPoint;
  p2,p3:TPoint;
  gr:word;
  changed:boolean;
begin
  with Parent do begin
   p3:=Point(nx,ny);
   p2:=ALEForm.PaintBox1.ClientToScreen(p3);
   p.x:=GetRX(nx);
   p.y:=GetRY(ny);
   WhatHere(p,npol,n,tp);
   if (tp<>tpNone) and (tp<>tpPolygon) then begin
     case tp of
      tpVertex:p4:=@Polygons[npol].Vertices[n];
      tpObject:p4:=@Objects[n].Pos;
      tpPicture:p4:=@Pics[n].Pos;
      else p4:=nil;
     end;
     if not (ssShift in Shift) and not p4.Selected then
      ClearSelection;
     x:=nx;y:=ny;
     p4.Selected:=true;
   end;
   case tp of
     tpNone:OptionsForm.ShowModal;
     tpVertex, tpPolygon: begin
       changed:=false;
       if ALEForm.Grass1.Checked then
         Gr:=1 else Gr:=0;
       for i:=0 to High(Polygons) do with Polygons[i] do
        for j:=0 to High(Vertices) do with Vertices[j] do
          if Selected or (i = npol) then
           if Grass<>Gr then begin
             changed:=true;
           end;
       Modified:=Modified or changed;
       if changed then
       for i:=0 to High(Polygons) do with Polygons[i] do
        for j:=0 to High(Vertices) do with Vertices[j] do
          if Selected or (i = npol) then Grass:=Gr;
     end;
     tpPicture:with PictureForm do begin
       LoadFromPicture(Pics[n]);
       if ShowModal=mrOK then begin
         Modified:=true;
         for i:=0 to High(Pics) do
         if Pics[i].Pos.Selected then
           SaveToPicture(Pics[i]);
         SortPictures;
       end;
     end;
     tpObject:with ObjectForm do begin
       LoadFromObject(Objects[n]);
       if ShowModal=mrOK then
       for i:=0 to High(Objects) do with Objects[i] do
        if Pos.Selected and (typ<>4) then begin
         if typ=1 then begin
          j:=0;
          for k:=0 to High(Objects) do
           if Objects[k].typ=1 then inc(j);
         end else j:=2;
         if j<2 then AddMessage(MessageString[79],iWarning)
         else begin                 
           Modified:=true;
           SaveToObject(Objects[i]);
         end;
       end;
     end;
   end;
    Draw;
  end;
end;

procedure TSelectTool.KeyPressed(key: word);
var
  i,j:integer;
  iscopy:integer;
begin
  with Parent do
  case key of
    VK_ESCAPE: if State=stTransform then State:=stReady
               else ClearSelection;

    VK_DELETE:begin //Óäàëåíèå
      Modified:=true;
      i:=0;
      while i<=High(Polygons) do with Polygons[i] do begin
       j:=0;
       while j<=High(Vertices) do with Vertices[j] do begin
        if Selected then begin
          if DeleteVertex(i,j) then begin
            dec(i);
            break;
          end;
        end else inc(j);
       end;
       inc(i);
      end;
      i:=0;
      while i<=High(Objects) do with Objects[i],Pos do begin
        if Selected then begin
          if not DeleteObject(i) then inc(i);
        end else inc(i);
      end;
      i:=0;
      while i<=High(Pics) do with Pics[i].Pos do
       if Selected then DeletePicture(i)
       else inc(i);
    end;

    VK_INSERT:begin //Êîïèðîâàíèå
      Modified:=true;
      for i:=0 to High(Polygons) do with Polygons[i] do begin
       iscopy:=0;
       for j:=0 to High(Vertices) do with Vertices[j] do
        if Selected then inc(iscopy);
       if (iscopy>=3) then begin
         AddPolygon(Polygons[i]);
         j:=0;
         while (j<=High(Polygons[i].Vertices)) do begin
           if not Polygons[i].Vertices[j].Selected then
             DeleteVertex(i,j)
           else inc(j);
         end;
         for j:=0 to High(Polygons[i].Vertices) do begin
           Polygons[i].Vertices[j].x:=Polygons[i].Vertices[j].x+ddx/Zoom;
           Polygons[i].Vertices[j].y:=Polygons[i].Vertices[j].y+ddy/Zoom;
         end;                                          
         for j:=0 to High(Polygons[High(Polygons)].Vertices) do
           Polygons[High(Polygons)].Vertices[j].Selected:=false;
       end;
      end;
      for i:=0 to High(Objects) do with Objects[i],Pos do
       if Selected then
       if typ<>4 then begin
         AddObject(Objects[i]);
         Objects[i].Pos.x:=Objects[i].Pos.x+ddx/Zoom;
         Objects[i].Pos.y:=Objects[i].Pos.y+ddy/Zoom;
         Objects[High(Objects)].Pos.Selected:=false;
       end;
      for i:=0 to High(Pics) do
       if Pics[i].Pos.Selected then begin
         AddPicture(Pics[i]);
         Pics[i].Pos.x:=Pics[i].Pos.x+ddx/Zoom;
         Pics[i].Pos.y:=Pics[i].Pos.y+ddy/Zoom;
         Pics[High(Pics)].Pos.Selected:=false;
       end;
       //ALEForm.StatusBar1.Panels[3].Text:=IntToStr(Length(Polygons));
    end;
  end;
end;

procedure TSelectTool.MouseDown(Shift: TShiftState;nx, ny: integer);
var
  npol,n,tp,i,j:integer;
  pts:TTransArray;
  sng:boolean;
  //pt:TPoint;

function Near2(p:TPoint):boolean;
begin
  Result:=sqrt(sqr(nx-p.x)+sqr(ny-p.y))<Parent.RNear;
end;

begin
  with Parent do
  if State=stReady then begin
    System.New(p);
    sng:=SnapToGrid;
    SnapToGrid:=false;
    p.x:=GetRX(nx);
    p.y:=GetRY(ny);
    SnapToGrid:=sng;
    WhatHere(p^,npol,n,tp);
    Dispose(p);
    case tp of
     tpNone:begin
      x:=nx;y:=ny;
      x2:=nx;y2:=ny;
      State:=stSelRect;
     end;
     tpVertex, tpObject, tpPicture, tpPolygon: begin
       curm:=false;
       case tp of
         tpVertex, tpPolygon:if ShowPolygons and (ShowGrass or (Polygons[npol].Grass=0)) then p:=@Polygons[npol].Vertices[n] else exit;
         tpObject:if ShowObjects then p:=@Objects[n].Pos else exit;
         tpPicture:if ShowPictures or Framepictures then p:=@Pics[n].Pos else exit;
       end;
       if not (ssShift in Shift) and not (ssCtrl in Shift) and not p.Selected then
        ClearSelection;
       State:=stMove;
       x:=nx;y:=ny;
       //pt.X:=GetOX(p.x);
       //pt.Y:=GetOY(p.y);
       corx:=p.x-GetRX(nx);
       cory:=p.y-GetRY(ny);
       //ClientToScreen(ALEForm.PaintBox1.Handle,pt);
       //SetCursorPos(pt.x,pt.y);
       if (tp<>tpPolygon) then begin
         if not (ssAlt in Shift) then
         if (ssCtrl in Shift) then
          p.Selected:=not p.Selected
         else p.Selected:=true;
       end;
       if ((ssAlt in Shift) and (tp=tpVertex)) or (tp=tpPolygon) then
        for i:=0 to High(Polygons[npol].Vertices) do
         if (ssCtrl in Shift) then
           Polygons[npol].Vertices[i].Selected:=not Polygons[npol].Vertices[i].Selected
         else Polygons[npol].Vertices[i].Selected:=true;
     end;
    end;
  end;
  if State=stTransform then begin
    pts:=GenPoints;
    MovingT:=false;
    for i:=0 to 2 do begin
     for j:=0 to 2 do
       if Near2(pts[i,j]) then begin
         MovingT:=true;
         break;
       end;
     if MovingT then break;
    end;
    if not MovingT then exit;
    Parent.Modified:=true;
    State:=stTransform;
    im:=i;jm:=j;
    x:=nx;y:=ny;
  end;
end;

procedure TSelectTool.MouseMove(Shift: TShiftState;nx, ny: integer);
var
  i,j:integer;
  drx,dry,rad,rado,m,cosa,sina,det:double;
  r,ro:TRPoint;
  VUpo,VRighto:TRPoint;
  xy,xx,yx,yy,xd,yd:double;
begin
  if (x = nx) and (y = ny) then exit;
  x2:=nx;y2:=ny;
  with Parent do
  if State=stEdit then begin
    drx:=-p.x+corx+GetRX(nx);
    dry:=-p.y+cory+GetRY(ny);
    if ShowPolygons then
    for i:=0 to High(Polygons) do with Polygons[i] do
     for j:=0 to High(Vertices) do with Vertices[j] do
      if Selected then begin
       if not curm then begin
         Modified:=true;
         curm:=true;
       end;
       x:=x+drx;
       y:=y+dry;
      end;
    if ShowObjects then
    for i:=0 to High(Objects) do with Objects[i].Pos do
     if Selected then begin
       if not curm then begin
         Modified:=true;
         curm:=true;
       end;
       x:=x+drx;
       y:=y+dry;
     end;
    if ShowPictures or Framepictures then
    for i:=0 to High(Pics) do with Pics[i].Pos do
     if Selected then begin
       if not curm then begin
         Modified:=true;
         curm:=true;
       end;
       x:=x+drx;
       y:=y+dry;
     end;
    x:=x2;y:=y2;
  end;
  with Parent do
  if (State=stTransform) and (MovingT) then begin
    VUpo:=VUp;
    VRighto:=VRight;
    xx:=1;xy:=0;yx:=0;yy:=1;xd:=0;yd:=0;
    //Ïåðåíîñ öåíòðà
    if (im=1) and (jm=1) then begin
      xd:=(x2-x)/Zoom;
      yd:=(y2-y)/Zoom;
      Centre.x:=Centre.x+xd;
      Centre.y:=Centre.y+yd;
    end else
    //Ïåðåíîñ ñåðåäèí
    if (im=1) then begin
      VUp.x:=VUp.x-(jm-1)*(x2-x)/Zoom;
      VUp.y:=VUp.y-(jm-1)*(y2-y)/Zoom;
    end else
    if (jm=1) then begin
      VRight.x:=VRight.x-(im-1)*(x2-x)/Zoom;
      VRight.y:=VRight.y-(im-1)*(y2-y)/Zoom;
    end else
    //Ïåðåíîñ êðà¸â
    if (im=jm) then begin
      ro.x:=(im-1)*(VUp.x+VRight.x);
      ro.y:=(im-1)*(VUp.y+VRight.y);
      rado:=sqrt(ro.x*ro.x+ro.y*ro.y);
      r.x:=ro.x-(x2-x)/Zoom;
      r.y:=ro.y-(y2-y)/Zoom;
      rad:=sqrt(r.x*r.x+r.y*r.y);
      if (abs(rad)<1e-10) or (abs(rado)<1e-10) then exit;
      m:=rad/rado;
      cosa:=(r.x*ro.x+r.y*ro.y)/rad/rado;
      sina:=-(r.x*ro.y-r.y*ro.x)/rad/rado;
      xx:=m*cosa;  xy:=-m*sina;
      yx:=m*sina;  yy:=m*cosa;
      VUp.x:=xx*VUpo.x+xy*VUpo.y;
      VUp.y:=yx*VUpo.x+yy*VUpo.y;
      VRight.x:=xx*VRighto.x+xy*VRighto.y;
      VRight.y:=yx*VRighto.x+yy*VRighto.y;
    end else begin
      ro.x:=-(im-1)*(VUp.x-VRight.x);
      ro.y:=-(im-1)*(VUp.y-VRight.y);
      rado:=sqrt(ro.x*ro.x+ro.y*ro.y);
      r.x:=ro.x-(x2-x)/Zoom;
      r.y:=ro.y-(y2-y)/Zoom;
      rad:=sqrt(r.x*r.x+r.y*r.y);
      if (abs(rad)<1e-10) or (abs(rado)<1e-10) then exit;
      m:=rad/rado;
      cosa:=(r.x*ro.x+r.y*ro.y)/rad/rado;
      sina:=-(r.x*ro.y-r.y*ro.x)/rad/rado;
      xx:=m*cosa;  xy:=-m*sina;
      yx:=m*sina;  yy:=m*cosa;
      VUp.x:=xx*VUpo.x+xy*VUpo.y;
      VUp.y:=yx*VUpo.x+yy*VUpo.y;
      VRight.x:=xx*VRighto.x+xy*VRighto.y;
      VRight.y:=yx*VRighto.x+yy*VRighto.y;
    end;
    if ((im=1) or (jm=1)) and (im*jm<>1) then begin
      det:=VUpo.x*VRighto.y-VUpo.y*VRighto.x;
      if abs(det)<1e-10 then begin //Ïðåäûäóùèé áûë â îäíó ëèíèþ
      end else begin
        xx:=1/det*(VUp.x*VRighto.y-VRight.x*VUpo.y);
        xy:=1/det*(-VUp.x*VRighto.x+VRight.x*VUpo.x);
        yx:=1/det*(VUp.y*VRighto.y-VRight.y*VUpo.y);
        yy:=1/det*(-VUp.y*VRighto.x+VRight.y*VUpo.x);
      end;
    end;
    x:=x2;y:=y2;
    //Ïðåîáðàçîâíèå âåðøèí
    for i:=0 to High(Polygons) do with Polygons[i] do
     for j:=0 to High(Vertices) do with Vertices[j] do
      if Selected then begin
        ro.x:=Vertices[j].x-Centre.x;
        ro.y:=Vertices[j].y-Centre.y;
        x:=xx*ro.x+xy*ro.y+xd+Centre.x;
        y:=yx*ro.x+yy*ro.y+yd+Centre.y;
      end;
    for i:=0 to High(Objects) do with Objects[i].Pos do
     if Selected then begin
       ro.x:=Objects[i].Pos.x-Centre.x;
       ro.y:=Objects[i].Pos.y-Centre.y;
       x:=xx*ro.x+xy*ro.y+xd+Centre.x;
       y:=yx*ro.x+yy*ro.y+yd+Centre.y;
     end;
    for i:=0 to High(Pics) do with Pics[i].Pos do
     if Selected then begin
       ro.x:=Pics[i].Pos.x-Centre.x;
       ro.y:=Pics[i].Pos.y-Centre.y;
       x:=xx*ro.x+xy*ro.y+xd+Centre.x;
       y:=yx*ro.x+yy*ro.y+yd+Centre.y;
     end;
  end;
end;

procedure TSelectTool.MouseUp(Shift: TShiftState;nx, ny: integer);
var
  r:TRect;
  i,j:integer;
begin
  with Parent do
  if State=stSelRect then begin
    x2:=nx;y2:=ny;
    if x2>=x then begin
      R.Left:=x;
      R.Right:=x2;
    end else begin
      R.Left:=x2;
      R.Right:=x;
    end;
    if y2>=y then begin
      R.Top:=y;
      R.Bottom:=y2;
    end else begin
      R.Top:=y2;
      R.Bottom:=y;
    end;
    if ShowPolygons then
    for i:=0 to High(Polygons) do with Polygons[i] do
     if (ShowGrass or (Polygons[i].Grass<>1)) then
     for j:=0 to High(Vertices) do with Vertices[j] do
      if PtInRect(r,Point(GetOX(x),GetOY(y))) then begin
        if (ssCtrl in Shift) then
          Selected:=not Selected
        else Selected:=true
      end else
        if not (ssShift in Shift) and not (ssCtrl in Shift) then Selected:=false;
    if ShowObjects then
    for i:=0 to High(Objects) do with Objects[i].Pos do
      if PtInRect(r,Point(GetOX(x),GetOY(y))) then begin
        if (ssCtrl in Shift) then
          Selected:=not Selected
        else Selected:=true
      end else
        if not (ssShift in Shift) and not (ssCtrl in Shift) then Selected:=false;
    if ShowPictures or Framepictures then
    for i:=0 to High(Pics) do with Pics[i].Pos do
      if PtInRect(r,Point(GetOX(x),GetOY(y))) then begin
        if (ssCtrl in Shift) then
          Selected:=not Selected
        else Selected:=true
      end else
        if not (ssShift in Shift) and not (ssCtrl in Shift) then Selected:=false;
  end;                                      
  MovingT:=false;
  if State=stTransform then State:=stTransform;
  if State<>stTransform then State:=stReady;
end;

procedure TSelectTool.Replace(tip: integer);
var
  mr:integer;
  Objct:TEObject;
  Pic:TEPicture;
  i,j,k:integer;

procedure Add(p:TRpoint);
begin
  if tip=0 then begin
    Objct.Pos:=p;
    Parent.AddObject(Objct);
  end else begin
    Pic.Pos:=p;
    Parent.AddPicture(Pic);
  end;
end;

begin
  if tip=0 then mr:=ObjectForm.ShowModal
  else mr:=PictureForm.ShowModal;
  if mr=mrCancel then exit;
  if tip=0 then ObjectForm.SaveToObject(Objct)
  else PictureForm.SaveToPicture(Pic);
  with Parent do begin
    Modified:=true;
    i:=0;
    while i<=High(Polygons) do with Polygons[i] do begin
      for j:=0 to High(Vertices) do
      if Vertices[j].Selected then Add(Vertices[j]);
      j:=0;
      while j<=High(Vertices) do with Vertices[j] do begin
       if Selected then begin
        if DeleteVertex(i,j) then begin
          dec(i);
          break;
        end;
       end else inc(j);
      end;
      inc(i);
    end;
    i:=0;
    while i<=High(Objects) do with Objects[i],Pos do begin
      if Selected then begin
        if tip=0 then begin
         case typ of
          1: begin
            j:=0;
            for k:=0 to High(Objects) do
              if Objects[k].typ=1 then inc(j);
            if j>=2 then begin
              Objct.Pos:=Objects[i].Pos;
              Objects[i]:=Objct;
            end else AddMessage(MessageString[8],iWarning);
          end;
          2,3: begin
            Objct.Pos:=Objects[i].Pos;
            Objects[i]:=Objct;
            inc(i);
          end;
          4: AddMessage(MessageString[7],iWarning);
         end;
         inc(i);
        end else begin
          if not DeleteObject(i) then inc(i)
          else Add(Objects[i].Pos);
        end;
      end else inc(i);
    end;
    i:=0;
    while i<=High(Pics) do with Pics[i].Pos do
    if Selected then begin
      if tip=1 then begin
        Pic.Pos:=Pics[i].Pos;
        Pics[i]:=Pic;
        inc(i);
      end else begin
        DeletePicture(i);
        Add(Pics[i].Pos);
      end;
    end else inc(i);
  end;
end;

procedure TSelectTool.SelectAll;
begin
  SetSelState(true);
end;

procedure TSelectTool.SetSelState(sel: boolean);
var
  i,j:integer;
begin
  with Parent do begin
    if ShowPolygons then
    for i:=0 to High(Polygons) do with Polygons[i] do
     if ShowGrass or (Grass=0) then
     for j:=0 to High(Vertices) do
      Vertices[j].Selected:=sel;
    if ShowObjects then
    for i:=0 to High(Objects) do
      Objects[i].Pos.Selected:=sel;
    for i:=0 to High(Pics) do
     if ((Pics[i].Name<>'') and ShowPictures) or
        ((Pics[i].Name='') and ShowTextures) then
      Pics[i].Pos.Selected:=sel;
  end;
end;

procedure TSelectTool.Setstate(const Value: integer);
begin
  if (Value<>stTransform) or ((Value=stTransform) and MovingT) then Inherited
  else begin
    Inherited Setstate(stReady);
    Fstate:=stTransform;
  end;
end;

procedure TSelectTool.StartTransformation;
var
  maxx,minx,maxy,miny:double;
  i,j:integer;
  was:boolean;
begin
  if State=stTransform then exit;
  MovingT:=false;
  maxx:=-1e32;
  minx:=1e32;
  maxy:=-1e32;
  miny:=1e32;
  was:=false;
  with Parent do begin
    for i:=0 to High(Polygons) do with Polygons[i] do
     for j:=0 to High(Vertices) do with Vertices[j] do
     if Selected then begin
       maxx:=Max(maxx,x);
       minx:=Min(minx,x);
       maxy:=Max(maxy,y);
       miny:=Min(miny,y);
       was:=true;
     end;
    for i:=0 to High(Objects) do with Objects[i].Pos do
    if Selected then begin
      maxx:=Max(maxx,x);
      minx:=Min(minx,x);
      maxy:=Max(maxy,y);
      miny:=Min(miny,y);
      was:=true;
    end;
    for i:=0 to High(Pics) do with Pics[i],Pos do
    if Selected then begin
      maxx:=Max(maxx,x);
      minx:=Min(minx,x);
      maxy:=Max(maxy,y);
      miny:=Min(miny,y); 
      was:=true;
    end;
  end;
  if not was then exit;
  State:=stTransform;
  Centre.x:=(maxx+minx)/2;
  Centre.y:=(maxy+miny)/2;
  VUp.x:=0;
  VUp.y:=(maxy-miny)/2;
  VRight.x:=(maxx-minx)/2;
  VRight.y:=0;
  if (abs(VUp.y)<1e-7) and (abs(VRight.x)<1e-7) then state:=stReady;
end;

{ TCreatePictureTool }

procedure TCreatePictureTool.Draw;
begin
  with Parent do begin
   Picture.Pos.x:=GetRX(x);
   Picture.Pos.y:=GetRY(y);
   DrawPicture(Picture);
  end;
end;

procedure TCreatePictureTool.MouseDown(Shift: TShiftState; nx,
  ny: integer);
begin
  x:=nx;y:=ny;
  with Picture do
  if (Name='') and ((Texture='') or (Mask='')) then exit;
  with Parent do begin
    Modified:=true;
    Picture.Pos.x:=GetRX(x);
    Picture.Pos.y:=GetRY(y);
    AddPicture(Picture);
    SortPictures;
  end;
  State:=stMove;
end;

procedure TCreatePictureTool.MouseMove(Shift: TShiftState; nx,
  ny: integer);
begin
  if (x <> nx) or (y <> ny) then
  if (ssShift in Shift) and (State = stMove) then
    MouseDown(Shift,nx,ny);
  x:=nx;y:=ny;
end;

procedure TCreatePictureTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  x:=nx;y:=ny;
  State:=stReady;
end;

{ TZoomRectTool }

procedure TZoomRectTool.Draw;
begin
  if State=stMove then
  with Parent,DXDraw.Surface.Canvas do begin
    Pen.Style:=psSolid;
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Brush.Style:=bsClear;
    Rectangle(x,y,x2,y2);
  end;
end;

procedure TZoomRectTool.MouseDown(Shift: TShiftState; nx, ny: integer);
begin
  x:=nx;y:=ny;
  x2:=nx;y2:=ny;
  State:=stMove;
end;

procedure TZoomRectTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
  x2:=nx;y2:=ny;
end;

procedure TZoomRectTool.MouseUp(Shift: TShiftState; nx, ny: integer);
var
  dx,dy:integer;
begin
  x2:=nx;y2:=ny;
  if x2=x then inc(x2);
  if y2=y then inc(y2);
  if State=stMove then with Parent do begin
    dx:=x2-x;dy:=y2-y;
    if dx<0 then begin
      dx:=x;x:=x2;x2:=dx;dx:=x2-x;
    end;
    if dy<0 then begin
      dy:=y;y:=y2;y2:=dy;dy:=y2-y;
    end;
    MoveCenter(-(Width-x-x2) div 2,-(Height-y-y2) div 2);
    if Height*dx>Width*dy then Zoom:=Zoom*Width/dx
    else Zoom:=Zoom*Height/dy;
    State:=stReady;
  end;
end;

{ TCreateRectTool }

procedure TCreateRectTool.Draw;
begin
  if State=stEdit then
  with Parent,DXDraw.Surface.Canvas do begin
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Pen.Style:=psSolid;
    Brush.Style:=bsClear;
    Rectangle(x,y,x2,y2);
  end;
end;

procedure TCreateRectTool.MouseDown(Shift: TShiftState; nx, ny: integer);
begin
  State:=stEdit;
  x:=nx;y:=ny;
  x2:=nx;y2:=ny;
end;

procedure TCreateRectTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
  x2:=nx;y2:=ny;
end;

procedure TCreateRectTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  if State=stEdit then
  with Parent do begin
    State:=stReady;
    Modified:=true;
    SetLength(Polygons,Length(Polygons)+1);
    with Polygons[High(Polygons)] do begin
      Grass:=0;
      SetLength(Polygons[High(Polygons)].Vertices,4);
      Vertices[0].x:=GetRX(x);
      Vertices[0].y:=GetRY(y);
      Vertices[1].x:=GetRX(x2);
      Vertices[1].y:=GetRY(y);
      Vertices[2].x:=GetRX(x2);
      Vertices[2].y:=GetRY(y2);
      Vertices[3].x:=GetRX(x);
      Vertices[3].y:=GetRY(y2);
    end;
  end;
end;

{ TCreateEllipseTool }

procedure TCreateEllipseTool.Draw;
var
  i,dx,dy:integer;
  Points:array of TPoint;
begin
  if State=stEdit then with Parent,DXDraw.Surface.Canvas do begin
    dx:=abs(x2-x);
    dy:=abs(y2-y);
    SetLength(Points,n+1);
    for i:=0 to n do begin
      Points[i].x:=x+round(cos(2*pi*i/n)*dx);
      Points[i].y:=y+round(sin(2*pi*i/n)*dy);
    end;
    Brush.Style:=bsClear;
    Pen.Color:=SwapColors(Palette[lvPoly]);
    Pen.Style:=psSolid;
    Polyline(Points);
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Pen.Style:=psDot;
    Rectangle(x-dx,y-dy,x+dx,y+dy);
    Ellipse(x-dx,y-dy,x+dx,y+dy);
  end;
end;

procedure TCreateEllipseTool.KeyPressed(key: word);
begin
  if State=stEdit then
  case key of
    VK_ESCAPE:begin
      State:=stReady;
      ALEForm.StatusBar1.Panels[StNum].Text:='';
    end;
    107,187,109,189:begin
      case key of
        107,187:inc(n);
        109,189:if n>3 then dec(n);
      end;
      ALEForm.StatusBar1.Panels[StNum].Text:=Format(MessageString[78],[n]);
    end;
    VK_RETURN:MouseDown([],x2,y2);
  end;
end;

procedure TCreateEllipseTool.MouseDown(Shift: TShiftState; nx,
  ny: integer);
var
  Poly:TPolygon;
  dx,dy,i:integer;
begin
  if State=stReady then begin
    State:=stEdit;
    x:=nx;y:=ny;
    x2:=nx;y2:=ny;
    n:=20;
    ALEForm.StatusBar1.Panels[StNum].Text:=Format(MessageString[78],[n]);
  end else
  if State=stEdit then with Parent do begin
    State:=stReady;
    dx:=abs(x2-x);
    dy:=abs(y2-y);
    Poly.Grass:=0;
    SetLength(Poly.Vertices,n);
    for i:=0 to n-1 do with Poly do begin
      Vertices[i].x:=GetRX(x)+cos(2*pi*i/n)*dx/Zoom;
      Vertices[i].y:=GetRY(y)+sin(2*pi*i/n)*dy/Zoom;
    end;
    Modified:=true;
    AddPolygon(Poly);                           
    ALEForm.StatusBar1.Panels[StNum].Text:='';
  end;
end;

procedure TCreateEllipseTool.MouseMove(Shift: TShiftState; nx,
  ny: integer);
begin
  if (ssShift in Shift) and (State=stEdit) then begin
    x:=x+nx-x2;
    y:=y+ny-y2;
  end;
  x2:=nx;y2:=ny;
end;

procedure TCreateEllipseTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  //
end;

{ TCutSplitTool }

procedure TCutSplitTool.Draw;
var
  l1,l2:integer;
  p0,p1,p2,p3:TPoint;
  pr:TRPoint;
begin
  if State=stOnePoint then
  with Parent,DXDraw.Surface.Canvas do begin
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Pen.Style:=psDot;
    MoveTo(x,y);
    LineTo(x2,y2);
  end;
  if State=stTwoPoints then
  with Parent,DXDraw.Surface.Canvas do begin
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Pen.Style:=psSolid;
    l1:=Length(Polygons[npol1].Vertices);
    l2:=Length(Polygons[npol2].Vertices);
    pr:=Polygons[npol1].Vertices[(n1-1+l1) mod l1];
    p0:=Point(GetOX(pr.x),GetOY(pr.y));
    pr:=Polygons[npol1].Vertices[(n1+1) mod l1];
    p1:=Point(GetOX(pr.x),GetOY(pr.y));
    pr:=Polygons[npol2].Vertices[(n2-1+l2) mod l2];
    p2:=Point(GetOX(pr.x),GetOY(pr.y));
    pr:=Polygons[npol2].Vertices[(n2+1) mod l2];
    p3:=Point(GetOX(pr.x),GetOY(pr.y));
    MoveTo(p0.X,p0.Y);
    LineTo(GetOX(pt[0].x),GetOY(pt[0].y));
    if not Invert then begin
      LineTo(GetOX(pt[2].x),GetOY(pt[2].y));
      LineTo(p2.x,p2.y);
    end else begin
      LineTo(GetOX(pt[3].x),GetOY(pt[3].y));
      LineTo(p3.x,p3.y);
    end;
    MoveTo(p1.X,p1.Y);
    LineTo(GetOX(pt[1].x),GetOY(pt[1].y));
    if Invert then begin
      LineTo(GetOX(pt[2].x),GetOY(pt[2].y));
      LineTo(p2.x,p2.y);
    end else begin
      LineTo(GetOX(pt[3].x),GetOY(pt[3].y));
      LineTo(p3.x,p3.y);
    end;
  end;
end;

procedure TCutSplitTool.KeyPressed(key: word);
var
  Poly:TPolygon;
  l1,l2,i,j,k,dn:integer;
begin
  case key of
    VK_ESCAPE:State:=stReady;
    VK_SPACE:invert:=not invert;
    VK_RETURN:if State=stTwoPoints then with Parent do begin
      State:=stReady;
      if npol1<>npol2 then begin
        Poly.Grass:=Polygons[npol1].Grass;
        l1:=Length(Polygons[npol1].Vertices);
        l2:=Length(Polygons[npol2].Vertices);
        SetLength(Poly.Vertices,l1+l2+2);
        i:=0;
        for j:=0 to l1-1 do
        if j<>n1 then begin
          Poly.Vertices[i]:=Polygons[npol1].Vertices[j];
          inc(i);
        end else begin
          Poly.Vertices[i]:=pt[0];
          if invert then begin
            inc(i);
            Poly.Vertices[i]:=pt[3];
            k:=(n2+1) mod l2;
            inc(i);
            while (k<>n2) do begin
             Poly.Vertices[i]:=Polygons[npol2].Vertices[k];
             inc(i);
             k:=(k+1) mod l2;
            end;
            Poly.Vertices[i]:=pt[2];
            inc(i);
            Poly.Vertices[i]:=pt[1];
            inc(i);
          end else begin
            inc(i);
            Poly.Vertices[i]:=pt[2];
            k:=(n2-1+l2) mod l2;
            inc(i);
            while (k<>n2) do begin
             Poly.Vertices[i]:=Polygons[npol2].Vertices[k];
             inc(i);
             k:=(k-1+l2) mod l2;
            end;
            Poly.Vertices[i]:=pt[3];
            inc(i);
            Poly.Vertices[i]:=pt[1];
            inc(i);
          end;
        end;
        Modified:=true;
        if npol1>npol2 then begin
          DeletePolygon(npol1);
          DeletePolygon(npol2);
        end else begin
          DeletePolygon(npol2);
          DeletePolygon(npol1);
        end;
        AddPolygon(Poly);
      end else begin  //npol1=npol2         
        Modified:=true;
        Poly.Grass:=Polygons[npol1].Grass;
        l1:=Length(Polygons[npol1].Vertices);
        if n2>n1 then dn:=n2-n1 else dn:=n2-n1+l1;
        //ShowMessage(IntToStr(abs(n2-n1)+1));
        SetLength(Poly.Vertices,dn+1);
        Poly.Vertices[0]:=pt[1];
        j:=(n1+1) mod l1;
        i:=1;
        while (j<>n2) do begin
          Poly.Vertices[i]:=Polygons[npol1].Vertices[j];
          j:=(j+1) mod l1;
          inc(i);
        end;
        Poly.Vertices[i]:=pt[2];
        AddPolygon(Poly);
        SetLength(Poly.Vertices,l1-dn+1);
        Poly.Vertices[0]:=pt[0];
        j:=(n1-1+l1) mod l1;
        i:=1;
        while (j<>n2) do begin
          Poly.Vertices[i]:=Polygons[npol1].Vertices[j];
          j:=(j-1+l1) mod l1;
          inc(i);
        end;
        Poly.Vertices[i]:=pt[3];
        AddPolygon(Poly);
        DeletePolygon(npol1);
      end;
    end;
  end;
end;

procedure TCutSplitTool.MouseDown(Shift: TShiftState; nx, ny: integer);
var
  p:TRPoint;
  dx,dy,dr,koef:double;
  l1,l2,tp:integer;
begin
  case State of
    stReady:with Parent do begin
      x:=nx;y:=ny;
      p.x:=GetRX(nx);
      p.y:=GetRY(ny);
      WhatHere(p,npol1,n1,tp);
      if (tp=tpVertex) or (tp=tpPolygon) then begin
        State:=stOnePoint;
        x:=GetOX(Polygons[npol1].Vertices[n1].x);
        y:=GetOY(Polygons[npol1].Vertices[n1].y);
      end;
      invert:=false;
    end;
    stOnePoint:with Parent do begin
      x2:=nx;y2:=ny;
      p.x:=GetRX(nx);
      p.y:=GetRY(ny);
      WhatHere(p,npol2,n2,tp);
      if (tp=tpVertex) or (tp=tpPolygon) then begin
        l1:=Length(Polygons[npol1].Vertices);
        l2:=Length(Polygons[npol2].Vertices);
        if (npol1=npol2) then begin
         if(l1<4) then exit
         else if ((abs(n2-n1)=1) or (n2=n1) or (abs(n2-n1)=l1-1)) then exit;
        end;
        State:=stTwoPoints;
        //------
        dx:=Polygons[npol1].Vertices[(n1-1+l1) mod l1].x-
          Polygons[npol1].Vertices[(n1+1) mod l1].x;
        dy:=Polygons[npol1].Vertices[(n1-1+l1) mod l1].y-
          Polygons[npol1].Vertices[(n1+1) mod l1].y;
        dr:=sqrt(dx*dx+dy*dy);
        if dr<>0 then begin
          koef:=SpLength/Zoom/dr;
        end else koef:=0;
        if koef>SpKoef then koef:=SpKoef;
        pt[0].x:=Polygons[npol1].Vertices[n1].x+koef*
        (Polygons[npol1].Vertices[(n1-1+l1) mod l1].x-
         Polygons[npol1].Vertices[n1].x);
        pt[0].y:=Polygons[npol1].Vertices[n1].y+koef*
        (Polygons[npol1].Vertices[(n1-1+l1) mod l1].y-
         Polygons[npol1].Vertices[n1].y);
        pt[1].x:=Polygons[npol1].Vertices[n1].x+koef*
        (Polygons[npol1].Vertices[(n1+1) mod l1].x-
         Polygons[npol1].Vertices[n1].x);
        pt[1].y:=Polygons[npol1].Vertices[n1].y+koef*
        (Polygons[npol1].Vertices[(n1+1) mod l1].y-
         Polygons[npol1].Vertices[n1].y);
        //------
        dx:=Polygons[npol2].Vertices[(n2-1+l2) mod l2].x-
          Polygons[npol2].Vertices[(n2+1) mod l2].x;
        dy:=Polygons[npol2].Vertices[(n2-1+l2) mod l2].y-
          Polygons[npol2].Vertices[(n2+1) mod l2].y;
        dr:=sqrt(dx*dx+dy*dy);
        if dr<>0 then begin
          koef:=SpLength/Zoom/dr;
        end else koef:=0;
        if koef>SpKoef then koef:=SpKoef;
        pt[2].x:=Polygons[npol2].Vertices[n2].x+koef*
        (Polygons[npol2].Vertices[(n2-1+l2) mod l2].x-
         Polygons[npol2].Vertices[n2].x);
        pt[2].y:=Polygons[npol2].Vertices[n2].y+koef*
        (Polygons[npol2].Vertices[(n2-1+l2) mod l2].y-
         Polygons[npol2].Vertices[n2].y);
        pt[3].x:=Polygons[npol2].Vertices[n2].x+koef*
        (Polygons[npol2].Vertices[(n2+1) mod l2].x-
         Polygons[npol2].Vertices[n2].x);
        pt[3].y:=Polygons[npol2].Vertices[n2].y+koef*
        (Polygons[npol2].Vertices[(n2+1) mod l2].y-
         Polygons[npol2].Vertices[n2].y);
        //
        if (npol1=npol2) then Self.KeyPressed(VK_RETURN)
        else
        //Âûáèðàåì íåïåðåñåêàþùèéñÿ âàðèàíò
          if Parent.Intersect(pt[0],pt[2],pt[1],pt[3],p) then
            invert:= not invert;
      end;
    end;
  end;
end;

procedure TCutSplitTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
  x2:=nx;y2:=ny;
end;

procedure TCutSplitTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  //
end;

procedure TCutSplitTool.Setstate(const Value: integer);
begin
  if Value<>stTwoPoints then Inherited
  else begin
    Inherited Setstate(stReady);
    FState:=Value;
  end;
  if State=stReady then Parent.InitUndoRedoVisible
  else begin
    ALEForm.Undo.Enabled:=false;
    ALEForm.Redo.Enabled:=false;
  end;
end;

{ TPictureTileTool }

procedure TPictureTileTool.Draw;
var
  i,j:integer;
begin
  if state=stReady then exit;
  with Parent do
  for i:=0 to Self.Width-1 do
   for j:=0 to Self.Height-1 do begin
     if not LeftToRight then Picture.Pos.x:=rx+i*tWidth
     else Picture.Pos.x:=rx+(Self.Width-i-1)*tWidth;
     if not TopToBottom then Picture.Pos.y:=ry+j*tHeight
     else Picture.Pos.y:=ry+(Self.Height-j-1)*tHeight;
     DrawPicture(Picture);
   end;
end;

procedure TPictureTileTool.KeyPressed(key: word);
var
  wassmth:boolean;
  step:double;
  i,j:integer;
begin
  if state=stReady then exit;
  wassmth:=true;
  step:=1/(Parent.Zoom*1.041);
  case key of
    VK_ESCAPE: begin
      state:=stReady;
      PictTileForm.Close;                            
      ALEForm.RealSize.ShortCut:=TextToShortCut('/');
    end;
    VK_NUMPAD3: tWidth:=tWidth+step;
    VK_NUMPAD1: if tWidth>=step then tWidth:=tWidth-step;
    VK_NUMPAD2: tHeight:=tHeight+step;
    VK_NUMPAD5: if tHeight>=step then tHeight:=tHeight-step;
    VK_NUMPAD9: inc(Width);
    VK_NUMPAD7: if Width>1 then dec(Width);
    VK_NUMPAD8: inc(Height);
    111: if Height>1 then dec(Height);
    VK_INSERT: LeftToRight:=not LeftToRight;
    VK_DELETE: TopToBottom:=not TopToBottom;
    VK_RETURN: with Parent do begin
      Modified:=true;
      for i:=0 to Self.Width-1 do
       for j:=0 to Self.Height-1 do begin
         if LeftToRight then Picture.Pos.x:=rx+i*tWidth
         else Picture.Pos.x:=rx+(Self.Width-i-1)*tWidth;
         if TopToBottom then Picture.Pos.y:=ry+j*tHeight
         else Picture.Pos.y:=ry+(Self.Height-j-1)*tHeight;
         AddPicture(Picture);
       end;
      SortPictures;
      state:=stReady;
      PictTileForm.Close;
      ALEForm.RealSize.ShortCut:=TextToShortCut('/');
    end;
    else wassmth:=false;
  end;
  if wassmth then PictTileForm.UpdateValues;
//  ShowMessage(IntToStr(key));
end;

procedure TPictureTileTool.MouseDown(Shift: TShiftState; nx, ny: integer);
var
  s:integer;
begin
  if state=stReady then begin
    LeftToRight:=true;
    TopToBottom:=true;
    rx:=Parent.GetRX(nx);ry:=Parent.GetRY(ny);
    Width:=2;
    Height:=2;
    if PictureForm.ShowModal=mrOK then begin
      PictureForm.SaveToPicture(Picture);
      if (Picture.Name='') and (Picture.Texture='') then exit;
      if Picture.Name<>'' then
        s:=Parent.SearchPic(Picture.Name)
      else s:=Parent.SearchPic(Picture.Mask);
      tWidth:=Parent.PC[s].Width*pz*1.041;
      tHeight:=Parent.PC[s].Height*pz*1.041;
      state:=stEdit;
      PictTileForm.Left:=ALEForm.Left+ALEForm.Width-PictTileForm.Width-20;
      PictTileForm.Top:=ALEForm.Top+130;
      PictTileForm.Show;
      ALEForm.RealSize.ShortCut:=0;
    end;
    Pressed:=false;
  end else begin
    x:=nx;y:=ny;
    Pressed:=true;
  end;
end;

procedure TPictureTileTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
  if (State=stEdit) and Pressed then begin
    rx:=rx+(nx-x)/Parent.Zoom;
    ry:=ry+(ny-y)/Parent.Zoom;
    x:=nx;y:=ny;
  end;
end;

procedure TPictureTileTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  Pressed:=false;
end;

procedure TPictureTileTool.Setstate(const Value: integer);
begin
  FState:=Value;
end;

{ TSplineTool }

procedure TSplineTool.CalculateCoef(P1, P2: TSVertex);
begin
  ax:=3*P2.dx+3*P1.dx+2*(P1.x-P2.x);
  bx:=P2.x-P1.x-3*P1.dx-ax;
  cx:=3*P1.dx;
  dx:=P1.x;
  ay:=3*P2.dy+3*P1.dy+2*(P1.y-P2.y);
  by:=P2.y-P1.y-3*P1.dy-ay;
  cy:=3*P1.dy;
  dy:=P1.y;
end;

constructor TSplineTool.Create(Par: TLevel);
begin
  inherited;
  SetLength(Poly,0);
  parts:=10;
end;

destructor TSplineTool.Destroy;
begin
  SetLength(Poly,0);
  KeyPressed(VK_ESCAPE);
  inherited;
end;

procedure TSplineTool.Draw;
var
  i,j:integer;
  Pts:array of TPoint;
  t:double;

procedure HighLightV(x,y:integer);
begin
  Parent.DXDraw.Surface.Canvas.Rectangle(x-1,y-1,x+2,y+2);
end;

begin
  if State<>stReady then
  with Parent,DXDraw.Surface.Canvas do begin
    Pen.Style:=psSolid;
    Brush.Style:=bsClear;
    for i:=0 to High(Poly) do begin
      Pen.Color:=SwapColors(Palette[lvVertex]);
      MoveTo(Poly[i].x-Poly[i].dx,Poly[i].y-Poly[i].dy);
      LineTo(Poly[i].x+Poly[i].dx,Poly[i].y+Poly[i].dy);
      Pen.Color:=SwapColors(Palette[lvHighlight]);
      HighLightV(Poly[i].x-Poly[i].dx,Poly[i].y-Poly[i].dy);
      HighLightV(Poly[i].x+Poly[i].dx,Poly[i].y+Poly[i].dy);
      HighLightV(Poly[i].x,Poly[i].y);
    end;
    //Ðèñîâàíèå ñïëàéíà ëîìàíîé
    Pen.Color:=SwapColors(Palette[lvPoly]);
    SetLength(Pts,parts+1);
    for i:=0 to High(Poly) do if Poly[i].Visible then begin
      CalculateCoef(Poly[i],Poly[(i+1) mod Length(Poly)]);
      for j:=0 to parts do begin
        t:=j/parts;
        Pts[j].X:=round(((ax*t+bx)*t+cx)*t+dx);
        Pts[j].y:=round(((ay*t+by)*t+cy)*t+dy);
      end;
      Polyline(Pts);
    end;
    //  
    Pen.Color:=SwapColors(Palette[lvVertex]);
    Pen.Style:=psDot;
    SetLength(Pts,4);
    for i:=0 to High(Poly) do if Poly[i].Visible then begin
      Pts[0].X:=Poly[i mod Length(Poly)].x;
      Pts[0].Y:=Poly[i mod Length(Poly)].y;
      //if i=Length(Poly) then break;
      Pts[1].X:=Poly[i].x+Poly[i].dx;
      Pts[1].Y:=Poly[i].y+Poly[i].dy;
      Pts[2].X:=Poly[(i+1) mod Length(Poly)].x-Poly[(i+1) mod Length(Poly)].dx;
      Pts[2].Y:=Poly[(i+1) mod Length(Poly)].y-Poly[(i+1) mod Length(Poly)].dy;
      Pts[3].X:=Poly[(i+1) mod Length(Poly)].x;
      Pts[3].Y:=Poly[(i+1) mod Length(Poly)].y;
      PolyBezier(Pts);
    end;
  end;
end;

function TSplineTool.FindVertex(nx, ny: integer;
  out sign: integer): integer;
var
  i:integer;

function Near2(px,py:integer):boolean;
begin
  Result:=sqrt(sqr(px-nx)+sqr(py-ny))<Parent.RNear;
end;

begin
  i:=0;
  while (i<=High(Poly)) do begin
    sign:=-1;
    if Near2(Poly[i].x-Poly[i].dx,Poly[i].y-Poly[i].dy) then break;
    sign:=1;
    if Near2(Poly[i].x+Poly[i].dx,Poly[i].y+Poly[i].dy) then break;
    sign:=0;
    if Near2(Poly[i].x,Poly[i].y) then break;
    inc(i);
  end;   
  Result:=i;
end;

procedure TSplineTool.KeyPressed(key: word);
var
  Polygon:TPolygon;
  i,j,cur,k,count:integer;
  t:double;
  Modif:boolean;
begin
  case key of
    VK_RETURN: if (State=stEdit) and (Length(Poly)>=2) then begin
      Polygon.Grass:=0;
      SetLength(Polygon.Vertices,Length(Poly)*parts);
      k:=-1;
      count:=0;
      for i:=0 to High(Poly) do begin
        if Poly[i].Visible then inc(count)
        else if k<0 then k:=i;
      end;
      if count=0 then begin
        Parent.AddMessage(MessageString[64],iInform);
        exit;
      end;
      if count=Length(Poly) then k:=0
      else
        while (not Poly[k].Visible) do begin
          inc(k);
          if k>High(Poly) then k:=0;
        end;
      i:=k;                                         
      cur:=0;
      Modif:=false;
      repeat
        if Poly[i].Visible then begin
          CalculateCoef(Poly[i],Poly[(i+1) mod Length(Poly)]);
          for j:=0 to parts-1 do begin
            t:=j/parts;
            Polygon.Vertices[cur].x:=Parent.GetRX(Poly[i].x)+(((ax*t+bx)*t+cx)*t+dx-Poly[i].x)/Parent.Zoom;
            Polygon.Vertices[cur].y:=Parent.GetRY(Poly[i].y)+(((ay*t+by)*t+cy)*t+dy-Poly[i].y)/Parent.Zoom;
            inc(cur);
          end;
        end;
        if (not Poly[i].Visible) then begin
          Polygon.Vertices[cur].x:=Parent.GetRX(Poly[i].x);
          Polygon.Vertices[cur].y:=Parent.GetRY(Poly[i].y);
          inc(cur);
          if (not OnePolygon) then begin
            SetLength(Polygon.Vertices,cur);
            cur:=0;
            if not Modif then begin
              Modif:=true;
              Parent.Modified:=true;
            end;
            Parent.AddPolygon(Polygon);
            SetLength(Polygon.Vertices,Length(Poly)*parts);
          end;
        end;// else inc(cur);
        inc(i);
        if i>High(Poly) then i:=0;
      until (i=k);
      if OnePolygon or (count=Length(Poly)) then begin
        SetLength(Polygon.Vertices,cur);
        Parent.Modified:=true;
        Parent.AddPolygon(Polygon);
      end;
      if DelSpline then begin
        state:=stReady;
        SplineForm.Close;
      end;
      SetLength(Polygon.Vertices,0);
      Parent.Draw;
    end;
    VK_ESCAPE: begin
      State:=stReady;
      //ALEForm.StatusBar1.Panels[3].Text:='';
    end;
    107,187,109,189:begin
      case key of
        107,187:inc(parts);
        109,189:if parts>1 then dec(parts);
      end;
      SplineForm.FormShow(nil);
      //ALEForm.StatusBar1.Panels[3].Text:='Parts : '+IntToStr(parts)+'. Press : Alt - for delete vertex; Shift - for add vertex';
    end;
  end;
end;

procedure TSplineTool.MouseDown(Shift: TShiftState; nx, ny: integer);
var
  i:integer;
  t:double;

begin
  if State=stReady then begin
    SetLength(Poly,1);
    Poly[0].x:=nx;
    Poly[0].y:=ny;
    Poly[0].dx:=30;
    Poly[0].dy:=0;
    State:=stEdit;
   // ALEForm.StatusBar1.Panels[3].Text:='Parts : '+IntToStr(parts)+'. Press : Alt - for delete vertex; Shift - for add vertex';
    exit;
  end;
  if State=stEdit then begin
    i:=FindVertex(nx,ny,signum);
    if i>High(Poly) then
    if Length(Poly)>=2 then begin
      Pressed:=true;
      exit;
    end else begin
      SetLength(Poly,2);
      Poly[1].x:=nx;
      Poly[1].y:=ny;
      Poly[1].dx:=-30;
      Poly[1].dy:=0;
      Poly[0].Visible:=true;
      Poly[1].Visible:=true;
      exit;
    end;
    cur:=i;
    if (signum<0) then cur:=(cur-1+Length(Poly)) mod Length(Poly);
    if ssShift in Shift then begin
      CalculateCoef(Poly[cur],Poly[(cur+1) mod Length(Poly)]);
      SetLength(Poly,Length(Poly)+1);
      for i:=High(Poly) downto cur+1 do
        Poly[i]:=Poly[i-1];
      t:=0.5;
      Poly[cur+1].x:=round(((ax*t+bx)*t+cx)*t+dx);
      Poly[cur+1].y:=round(((ay*t+by)*t+cy)*t+dy);
      Poly[cur+1].dx:=round(((3*ax*t+2*bx)*t+cx)/6);
      Poly[cur+1].dy:=round(((3*ay*t+2*by)*t+cy)/6);
      Poly[cur+1].Visible:=true;
    end else if ssAlt in Shift then begin 
      cur:=i;
      if Length(Poly)>=3 then begin
        for i:=cur to High(Poly)-1 do
         Poly[i]:=Poly[i+1];
        SetLength(Poly,High(Poly));
      end;
    end else if ssCtrl in Shift then begin
      if Length(Poly)>=2 then begin
        Poly[cur].Visible:=not Poly[cur].Visible;
      end;
    end else begin  
      cur:=i;
      state:=stMovePoint;
    end;
  end;
  x2:=nx;y2:=ny;
end;

procedure TSplineTool.MouseMove(Shift: TShiftState; nx, ny: integer);
var
  i:integer;
begin
  if State=stMovePoint then begin
    if signum<>0 then begin
      Poly[cur].dx:=signum*(nx-Poly[cur].x);
      Poly[cur].dy:=signum*(ny-Poly[cur].y);
    end else begin
      Poly[cur].x:=nx;
      Poly[cur].y:=ny;
    end;
  end else
  if Pressed and (State=stEdit) then
  for i:=0 to High(Poly) do with Poly[i] do begin
    x:=x+nx-x2;
    y:=y+ny-y2;
  end;
  x2:=nx;y2:=ny;
end;

procedure TSplineTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  if State=stMovePoint then State:=stEdit;
  Pressed:=false;
end;

procedure TSplineTool.ProcessRightClick(nx, ny: integer);
var
  i,signum:integer;
  p:TPoint;
begin
  i:=FindVertex(nx,ny,signum);
  if i>High(Poly) then begin
    if State=stEdit then
      SplineForm.Show;
  end else begin
    if signum>=0 then ALEForm.Visible1.Checked:=Poly[i].Visible
    else ALEForm.Visible1.Checked:=Poly[(i-1+Length(Poly)) mod Length(Poly)].Visible;
    p:=ALEForm.PaintBox1.ClientToScreen(Point(nx,ny));
    ALEForm.PopupMenu4.Popup(p.x,p.y);
  end;
end;

procedure TSplineTool.Setstate(const Value: integer);
begin
  Fstate:=Value;
  if State<>stEdit then begin
    Inherited;
    SplineForm.Hide;
  end else begin
    Inherited SetState(StReady);
    Fstate:=stEdit;
    SplineForm.Left:=ALEForm.Left+ALEForm.Width-SplineForm.Width-20;
    SplineForm.Top:=ALEForm.Top+130;
    SplineForm.Show;
  end;
end;

{ TPolyOpTool }

procedure TPolyOpTool.Draw;
var
  oGrass,oPoly:Cardinal;
begin
  if State=stReady then exit;
  with Parent do begin
    oGrass:=Palette[lvGrass];
    oPoly:=Palette[lvPoly];
    Palette[lvGrass]:=Palette[lvHighlight];
    Palette[lvPoly]:=Palette[lvHighlight];
    if state>=stOnePoint then DrawPolygon(@Polygons[n1]);
    if state=stTwoPoints then DrawPolygon(@Polygons[n2]);
    Palette[lvGrass]:=oGrass;
    Palette[lvPoly]:=oPoly;
  end;
end;

procedure TPolyOpTool.KeyPressed(key: word);
begin
  case key of
    VK_ESCAPE: begin
      State:=stReady;
      PolyOpForm.Close;
    end;
    VK_NUMPAD1: PerformOp(-1,-1);
    VK_NUMPAD2: PerformOp(1,1);
    VK_NUMPAD3: PerformOp(1,-1);
    VK_NUMPAD4: PerformOp(-1,1);
  end;
end;

procedure TPolyOpTool.MouseDown(Shift: TShiftState; nx, ny: integer);
var
  p:TRPoint;
  n,npol,tp:integer;
begin
  if State<>stTwoPoints then
  with Parent do begin
    p.x:=GetRX(nx);
    p.y:=GetRY(ny);
    WhatHere(p,npol,n,tp);
    if (tp=tpVertex) or (tp=tpPolygon) then begin
      if State=stReady then begin
        State:=stOnePoint;
        n1:=npol;
      end else begin
        if npol=n1 then exit;
        DelSource:=true;
        State:=stTwoPoints;
        n2:=npol;
        PolyOpForm.Left:=ALEForm.Left+ALEForm.Width-PolyOpForm.Width-20;
        PolyOpForm.Top:=ALEForm.Top+130;
        PolyOpForm.Show;
      end;
    end;
  end;
end;

procedure TPolyOpTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
//
end;

procedure TPolyOpTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
//
end;

procedure TPolyOpTool.PerformOp(or1, or2: integer);
type
  PList=^TList;
  PRPoint=^TRPoint;
  TList=record
    point:PRPoint;
    next:PList;
    neighbor:PList;
    inter:boolean;
    num:integer;
  end;

var
  Pol1,Pol2:TPolygon;
  WList,IList,InpList,icur:PList;
  wasint:boolean;

procedure FreeListC(list:PList);
var
  tmp:PList;
begin
  tmp:=list.next;
  list.next:=nil;
  list:=tmp;
  while (list<>nil) do begin
    tmp:=list.next;
    dispose(list);
    list:=tmp;
  end;
end;

procedure Delete(var list:PList;point:PRPoint);
var
  tmp,f:PList;
begin
  if (list=nil) then exit;
  if (list.point=point) then begin
    tmp:=list.next;
    Dispose(list);
    list:=tmp;
    exit;
  end;
  f:=list;
  while (f.next.point<>point) do begin
    f:=f.next;
    if (f.next=nil) then exit;
  end;
  tmp:=f.next;
  f.next:=f.next.next;
  Dispose(tmp);
end;

procedure AddPolVerticess(pol:PPolygon;var list:PList);
var
  cur:PList;
  i:integer;
begin
//Äîáàâëåíèå âåðøèí ïîëèãîíîâ
  cur:=nil;
  list:=nil;
  with pol^ do
  for i:=0 to High(Vertices) do begin
	  if (cur<>nil) then begin
      New(cur.next);
      cur:=cur.next;
	  end else New(cur);
	  if list=nil then list:=cur;
	  cur.point:=@Vertices[i];
    cur.inter:=false;
	  cur.next:=nil;
    cur.num:=0;
  end;
  cur.next:=list;
end;

function Intersect2(p1, p2, r1, r2: TRPoint;var t: PRPoint;needadd:boolean):boolean;
var
  m,n,tc,tp,t1,t2,tr:double;
begin
//p - îòñåêàòåëü, r - îòñåêàåìûé îáúåêò

//  m*(p2.x-p1.x)+p1.x=n*(r2.x-r1.x)+r1.x;
//  m*(p2.y-p1.y)+p1.y=n*(r2.y-r1.y)+r1.y;
  tc:=(p2.x-p1.x)*(r2.y-r1.y)-(p2.y-p1.y)*(r2.x-r1.x);
  tp:=(p1.y-r1.y)*(r2.x-r1.x)-(p1.x-r1.x)*(r2.y-r1.y);
  tr:=(r1.x-p1.x)*(p2.y-p1.y)-(r1.y-p1.y)*(p2.x-p1.x);
  Result:=false;
  if (tc=0) then begin
   Result:=false;
  end else begin
    m:=tp/tc;
    n:=tr/tc;
    //Ïîäñòàâëÿåì â óð-å ïðÿìîé p
    t1:=(r1.x-p1.x)*(p2.y-p1.y)-(r1.y-p1.y)*(p2.x-p1.x);
    t2:=(r2.x-p1.x)*(p2.y-p1.y)-(r2.y-p1.y)*(p2.x-p1.x);
    //Åñëè íà ãðàíèöå - çíà÷èò âíå
    if (t1=0) then t1:=1;
    if (t2=0) then t2:=1;
    //m=1 âûêîëîòà
    if ((m<1) and (m>=0) and (t1*t2<0) and (n<=1) and (n>=0)) then begin
      Result:=true;
      New(t);
      t.x:=(p2.x-p1.x)*m+p1.x;
      t.y:=(p2.y-p1.y)*m+p1.y;
      if (t1>0) and needadd then begin
        if (icur<>nil) then begin
          New(icur.next);
          icur:=icur.next;
        end else New(icur);
	  	  if (InpList=nil) then InpList:=icur;
        icur.point:=t;
	  	  icur.next:=nil;
      end;
    end;
  end;
end;

function InsertAfter(list:PList;point,ipoint:PRPoint):PList;
var
  start,ver:PList;
  r:double;
begin
//  start:=list;
  while ((list.point<>point) and (list.next<>nil)) do
    list:=list.next;
  if (list.point<>point) then begin
    Result:=nil;
    exit;
  end;

  ver:=list;

  r:=abs(ipoint.x-ver.point.x)+abs(ipoint.y-ver.point.y);
  while (r>abs(list.next.point.x-ver.point.x)+
           abs(list.next.point.y-ver.point.y)) do
    list:=list.next;
  ver:=list.next;
  New(start);
  start.next:=ver;
  start.point:=ipoint;
  start.inter:=true;
  list.next:=start;
  Result:=start;
end;

procedure CreateLists;
var
  k,l,k1,l1:integer;
  cur,i1,i2:PList;
  tmp:PRPoint;
  T,inpl:PList;
  Poly:TPolygon;
begin
  WList:=nil;
  IList:=nil;
  AddPolVerticess(@Pol1,WList);
  AddPolVerticess(@Pol2,IList);
  wasint:=false;

//Ïîèñê ïåðåñå÷åíèé
  cur:=nil;
  InpList:=nil;
  icur:=nil;
  
  with Parent do
  for k:=0 to High(Pol1.Vertices) do
  	for l:=0 to High(Pol2.Vertices) do begin
      k1:=(k+1) mod Length(Pol1.Vertices);
		  l1:=(l+1) mod Length(Pol2.Vertices);
//      tw=&Window.parts[i];
//      ti=&Image.parts[j];

		  if (Intersect2(Pol1.Vertices[k], Pol1.Vertices[k1],
          Pol2.Vertices[l], Pol2.Vertices[l1], tmp, true)) then begin
        wasint:=true;
        i1:=InsertAfter(WList,@Pol1.Vertices[k],tmp);
        i2:=InsertAfter(IList,@Pol2.Vertices[l],tmp);
        i1.num:=0;
        i2.num:=1;
        //Ïðîâÿçêà
        i1.neighbor:=i2;
        i2.neighbor:=i1;
        if (icur<>cur) then begin
          cur:=icur;
          cur.neighbor:=i2;
        end;
		  end;
		end;
//Ñîçäàíèå ïîëèãîíîâ äëÿ ðèñîâàíèÿ
  inpl:=InpList;
  Poly.Grass:=0;
  with Poly do
  while (inpl<>nil) do begin
    SetLength(Vertices,1);
  	Vertices[0]:=inpl.point^;
    //cur=cpol;
    T:=inpl.neighbor;
    repeat
      T:=T.next;
      if (T.inter) then begin
        T:=T.neighbor;
        if ((T.num=1) and (T<>inpl.neighbor)) then
          Delete(inpl,T.point);
      end;
      SetLength(Vertices,Length(Vertices)+1);
      Vertices[High(Vertices)]:=T.point^;
    until (T=inpl.neighbor);
    Delete(inpl,inpl.point);
    SetLength(Vertices,Length(Vertices)-1);
    Parent.AddPolygon(Poly);
  end;
  FreeListC(WList);
  FreeListC(IList);
  if not WasInt then ShowMessage(MessageString[59]);
end;


procedure SetOrient(Pol:PPolygon;orient:integer);
var
  i:integer;
  Vertex:TRPoint;
begin
  with Pol^ do begin
    if (Orientation=orReverse) xor (orient<0) then begin
      Orientation:=not Orientation;
      for i:=0 to (High(Vertices)-1) div 2 do begin
        Vertex:=Vertices[i];
        Vertices[i]:=Vertices[High(Vertices)-i];
        Vertices[High(Vertices)-i]:=Vertex;
      end;
    end;
  end;
end;

var
  i,j,i1,j1:integer;
  tmp:PRPoint;
  
begin
  if State<>stTwoPoints then exit;
  with Parent do begin
    Pol1.Vertices:=Copy(Polygons[n1].Vertices);
    Pol2.Vertices:=Copy(Polygons[n2].Vertices);
    CalcOrientation(@Pol1);
    CalcOrientation(@Pol2);
    SetOrient(@Pol1,or1);
    SetOrient(@Pol2,or2);
    with Pol1 do
    for i:=0 to High(Vertices) do
    	for j:=0 to High(Vertices) do begin
        i1:=(i+1) mod Length(Vertices);
			  j1:=(j+1) mod Length(Vertices);             
        if (i=j) or (i=j1) or (j=i1) then continue;
        if (Intersect2(Vertices[i], Vertices[i1],
          Vertices[j], Vertices[j1], tmp, false)) then begin
          Level.Center:=tmp^;
          Level.Zoom:=1000;
          Level.AddMessage(MessageString[60],iWarning);
          Level.Draw;
          exit;
        end;
      end;
    with Pol2 do
    for i:=0 to High(Vertices) do
    	for j:=0 to High(Vertices) do begin
        i1:=(i+1) mod Length(Vertices);
			  j1:=(j+1) mod Length(Vertices);
        if (i=j) or (i=j1) or (j=i1) then continue;
        if (Intersect2(Vertices[i], Vertices[i1],
          Vertices[j], Vertices[j1], tmp, false)) then begin
          Level.Center:=tmp^;
          Level.Zoom:=1000;
          Level.AddMessage(MessageString[60],iWarning);
          Level.Draw;
          exit;
        end;
      end;
    Modified:=true;
    //
    CreateLists;
    //
    if DelSource and WasInt then begin
      if n1>n2 then begin
        DeletePolygon(n1);
        DeletePolygon(n2);
      end else begin
        DeletePolygon(n2);
        DeletePolygon(n1);
      end;
    end;
    PolyOpForm.Close;
    State:=stReady;
  end;
end;

procedure TPolyOpTool.Setstate(const Value: integer);
begin
  Fstate := Value;
end;

{ TGrassTool }

constructor TGrassTool.Create(Par: TLevel);
begin
  inherited;
  n:=-1;
  GHeight:=0.4;
  GWidth:=True;
  Smoothing:=false;
  CorrectREdge:=false;
end;

procedure TGrassTool.Draw;
var
  oGrass,oPoly:Cardinal;
begin
  if State=stReady then exit;
  with Parent do begin
    oGrass:=Palette[lvGrass];
    oPoly:=Palette[lvPoly];
    Palette[lvGrass]:=Palette[lvHighlight];
    Palette[lvPoly]:=Palette[lvHighlight];
    DrawPolygon(@Polygons[n]);
    Palette[lvGrass]:=oGrass;
    Palette[lvPoly]:=oPoly;
  end;
end;

procedure TGrassTool.KeyPressed(key: word);
var
  maxx:integer;
  i,j:integer;
  Pol:TPolygon;
  IsCreating:boolean;
  NV,NV2:TRPoint;
  RightOrient,RightSlope:boolean;
  Modif:boolean;
  istart,iend,im1,ip1,l:integer;
  v1,v2,v:TRPoint;
  coss,sins,tmp:double;
  startheight,endheight,wh:double;

function GetBVector(v1,v2:TRPoint):TRPoint;
var
  v:TRPoint;
  cosa:double;
begin
  Parent.Normalize(v1);
  Parent.Normalize(v2);
  v.x:=v1.x+v2.x;
  v.y:=v1.y+v2.y;
  Parent.Normalize(v);
  if (v.x=0) and (v.y=0) then begin
    //Âåêòîðû ïàðàëëåëüíû
    v.x:=v1.y;
    v.y:=-v1.x;
  end;
  if v.y<0 then begin
    //Íàäî âíèç, à íå ââåðõ
    v.x:=-v.x;
    v.y:=-v.y;
  end;
  cosa:=v1.x*v.x+v1.y*v.y;
  cosa:=sqrt(1-cosa*cosa);
  if cosa<>0 then begin
    v.x:=v.x/cosa;
    v.y:=v.y/cosa;
  end else Parent.AddMessage(Format(MessageString[63],[0]),iWarning);
  //Grass error 0 - âåêòîðû ïàðàëëåëüíû
  //ïî èäåå, íå áûâàåò
  Result:=v;
end;

begin
  case key of
    VK_ESCAPE: State:=stReady;
    VK_RETURN: if State=stEdit then
    with Parent do begin
      if not FullTopChecked then CheckTopology(NV,true);
      l:=Length(Polygons[n].Vertices);
      with AutoGrassForm do begin
        GHeight:=WheelHeight/100*StrToFloat(LabeledEdit1.Text);
        Smoothing:=CheckBox1.Checked;
        CorrectREdge:=CheckBox2.Checked;
        GWidth:=CheckBox3.Checked;
      end;
      //MasSlope - tg
      //Íàéäåì sin è cos
      sins:=MaxSlope/sqrt(sqr(MaxSlope)+1);
      coss:=sqrt(1-sqr(sins));
      maxx:=0;
      for i:=1 to l-1 do
        if Polygons[n].Vertices[maxx].x<Polygons[n].Vertices[i].x then maxx:=i;
      i:=maxx;
      IsCreating:=true;
      Pol.Grass:=1;
      SetLength(Pol.Vertices,0);
      Modif:=false;
      istart:=i;
      repeat
        //Äîáàâëåíèå âåðøèíû
        if IsCreating then begin
          SetLength(Pol.Vertices,Length(Pol.Vertices)+1);
          Pol.Vertices[High(Pol.Vertices)]:=Polygons[n].Vertices[i];
          with Pol.Vertices[High(Pol.Vertices)] do
           if GWidth then begin
             im1:=(i-1+l) mod l;
             ip1:=(i+1) mod l;
             v1.x:=Polygons[n].Vertices[i].x-Polygons[n].Vertices[im1].x;
             v1.y:=Polygons[n].Vertices[i].y-Polygons[n].Vertices[im1].y;
             v2.x:=Polygons[n].Vertices[i].x-Polygons[n].Vertices[ip1].x;
             v2.y:=Polygons[n].Vertices[i].y-Polygons[n].Vertices[ip1].y;
             v:=GetBVector(v1,v2);

             x:=x+v.x*GHeight;
             y:=y+v.y*GHeight;
           end else
             y:=y+GHeight;
        end;
        NV:=Polygons[n].Vertices[(i+1) mod l];
        RightOrient:=(Polygons[n].Vertices[i].x>NV.x);
        RightSlope:=(abs(Polygons[n].Vertices[i].x-NV.x)>MaxSlope*abs(Polygons[n].Vertices[i].y-NV.y));
        if not (RightOrient and RightSlope) then begin
          //Ñâåðòûâàíèå
          if IsCreating then begin
            iend:=i;
            if Length(Pol.Vertices)>=2 then begin
              startheight:=GHeight;
              endheight:=GHeight;
              //Íà êðàÿõ ðîâíî âíèç
              if GWidth then begin
                //Åñëè íå "ãëàäêî"
                if (Pol.Vertices[1].x<Polygons[n].Vertices[istart].x) or (Length(Pol.Vertices)=2) then begin
                  ip1:=(istart+1) mod l;
                  v1.x:=Polygons[n].Vertices[istart].x-Polygons[n].Vertices[ip1].x;
                  v1.y:=Polygons[n].Vertices[istart].y-Polygons[n].Vertices[ip1].y;
                  v2.x:=-v1.x;
                  v2.y:=v1.y;
                  v:=GetBVector(v1,v2);
                  Pol.Vertices[0].x:=Polygons[n].Vertices[istart].x+v.x*GHeight;
                  Pol.Vertices[0].y:=Polygons[n].Vertices[istart].y+v.y*GHeight;
                  startheight:=v.y*GHeight;
                end;

                if (Pol.Vertices[High(Pol.Vertices)-1].x>Polygons[n].Vertices[iend].x) or (Length(Pol.Vertices)=2) then begin
                  im1:=(iend-1+l) mod l;
                  v2.x:=Polygons[n].Vertices[iend].x-Polygons[n].Vertices[im1].x;
                  v2.y:=Polygons[n].Vertices[iend].y-Polygons[n].Vertices[im1].y;
                  v1.x:=-v2.x;
                  v1.y:=v2.y;
                  v:=GetBVector(v1,v2);
                  Pol.Vertices[High(Pol.Vertices)].x:=Polygons[n].Vertices[iend].x+v.x*GHeight;
                  Pol.Vertices[High(Pol.Vertices)].y:=Polygons[n].Vertices[iend].y+v.y*GHeight;
                  endheight:=v.y*GHeight;
                end;
              end;
              if not Smoothing then
              if Length(Pol.Vertices)=2 then begin
                SetLength(Pol.Vertices,3);
                Pol.Vertices[2].x:=(Pol.Vertices[0].x+Pol.Vertices[1].x)/2;
                Pol.Vertices[2].y:=(Pol.Vertices[0].y+Pol.Vertices[1].y)/2;
              end;
              //Êîððåêòèðîâêà çàõîäà íà ñëåäóþùóþ ãðàíü
              //Left
              if (Polygons[n].Vertices[iend].x<Polygons[n].Vertices[(iend+1) mod l].x) then begin
                NV.x:=-(Polygons[n].Vertices[iend].x-Polygons[n].Vertices[(iend-1+l) mod l].x);
                NV.y:=-(Polygons[n].Vertices[iend].y-Polygons[n].Vertices[(iend-1+l) mod l].y);
                NV2.x:=-(Polygons[n].Vertices[iend].x-Polygons[n].Vertices[(iend+1) mod l].x);
                NV2.y:=-(Polygons[n].Vertices[iend].y-Polygons[n].Vertices[(iend+1) mod l].y);
                if (NV.x*NV2.y-NV.y*NV2.x)<0 then begin
                  //Òðàâà çàõîäèò çà ñëåä. ãðàíü
                  if (NV.x<>0) and (NV2.x<>0) then begin
                    if Smoothing then
                      wh:=WheelHeight
                    else wh:=WheelHeight-(Pol.Vertices[High(Pol.Vertices)].y-Polygons[n].Vertices[iend].y);
                    tmp:=-wh/(NV2.y/NV2.x-NV.y/NV.x);
                    if tmp<0 then tmp:=0;
                  end else begin
                    //Íå ïîâåçëî - ïîñëåäíÿÿ ñòîðîíà=0
                    tmp:=0;
                    Parent.AddMessage(Format(MessageString[63],[1]),iWarning);
                  end;
                  if (tmp<NV.x) then begin
                    Pol.Vertices[High(Pol.Vertices)].x:=Pol.Vertices[High(Pol.Vertices)].x+tmp;
                    Pol.Vertices[High(Pol.Vertices)].y:=Pol.Vertices[High(Pol.Vertices)].y+tmp*NV.y/NV.x;
                  end else begin
                    //Óäàëÿåì ïîñëåäíþþ âåðøèíó
                    SetLength(Pol.Vertices,High(Pol.Vertices));
                    Parent.AddMessage(Format(MessageString[63],[2]),iWarning);
                  end;
                end;
              end;
              //Right
              if (Polygons[n].Vertices[istart].x>Polygons[n].Vertices[(istart+1) mod l].x) then begin
                NV2.x:=-(Polygons[n].Vertices[istart].x-Polygons[n].Vertices[(istart-1+l) mod l].x);
                NV2.y:=-(Polygons[n].Vertices[istart].y-Polygons[n].Vertices[(istart-1+l) mod l].y);
                NV.x:=-(Polygons[n].Vertices[istart].x-Polygons[n].Vertices[(istart+1) mod l].x);
                NV.y:=-(Polygons[n].Vertices[istart].y-Polygons[n].Vertices[(istart+1) mod l].y);
                if (NV.x*NV2.y-NV.y*NV2.x)>0 then begin
                  //Òðàâà çàõîäèò çà ñëåä. ãðàíü
                  if (NV.x<>0) and (NV2.x<>0) then begin
                    if Smoothing then
                      wh:=WheelHeight
                    else wh:=WheelHeight-(Pol.Vertices[0].y-Polygons[n].Vertices[istart].y);
                    tmp:=wh/(NV2.y/NV2.x-NV.y/NV.x);
                    if tmp<0 then tmp:=0;
                  end else begin
                    //Íå ïîâåçëî - ïîñëåäíÿÿ ñòîðîíà=0
                    tmp:=0;
                    Parent.AddMessage(Format(MessageString[63],[1]),iWarning);
                  end;
                  if (tmp<-NV.x) then begin
                    Pol.Vertices[0].x:=Pol.Vertices[0].x-tmp;
                    Pol.Vertices[0].y:=Pol.Vertices[0].y-tmp*NV.y/NV.x;
                  end else begin
                    //Óäàëÿåì ïîñëåäíþþ âåðøèíó
                    for j:=0 to High(Pol.Vertices)-1 do
                      Pol.Vertices[j]:=Pol.Vertices[j+1];
                    SetLength(Pol.Vertices,High(Pol.Vertices));
                    Parent.AddMessage(Format(MessageString[63],[2]),iWarning);
                  end;
                end;
              end;
              //Êîððåêòèðîâêà ïðàâîãî êðàÿ
              if CorrectREdge then begin
                Pol.Vertices[0].x:=Pol.Vertices[0].x-MaxGrassWidth;
              end;
              //Íåáîëüøîå ñóæåíèå êðàåâ
              Pol.Vertices[0].x:=Pol.Vertices[0].x-1e-7;
              Pol.Vertices[High(Pol.Vertices)].x:=Pol.Vertices[High(Pol.Vertices)].x+1e-7;
              //Ñãëàæèâàíèå
              if Smoothing then begin
                SetLength(Pol.Vertices,Length(Pol.Vertices)+2);
                //Right
                v.x:=Pol.Vertices[1].x-Pol.Vertices[0].x;
                v.y:=Pol.Vertices[1].y-Pol.Vertices[0].y;
                Normalize(v);
                v1:=v;
                v.x:=v1.x*coss+v1.y*sins;
                v.y:=v1.y*coss-v1.x*sins;
                v.x:=v.x/sins*GHeight;
                v.y:=v.y/sins*GHeight;  
                if not GWidth then begin
                  tmp:=v1.x/v1.y/sqrt(sqr(v1.x/v1.y)+1);
                  v.x:=v.x*tmp;
                  v.y:=v.y*tmp;
                end;
                if v.x>0 then begin
                  v.x:=-v.x;
                  v.y:=-v.y;
                end;
                Pol.Vertices[High(Pol.Vertices)].x:=Pol.Vertices[0].x;
                Pol.Vertices[High(Pol.Vertices)].y:=Pol.Vertices[0].y-startheight-GHeight*0.01;
                Pol.Vertices[0].x:=Pol.Vertices[0].x+v.x;
                Pol.Vertices[0].y:=Pol.Vertices[0].y-startheight+v.y;

                //Left
                v.x:=Pol.Vertices[High(Pol.Vertices)-3].x-Pol.Vertices[High(Pol.Vertices)-2].x;
                v.y:=Pol.Vertices[High(Pol.Vertices)-3].y-Pol.Vertices[High(Pol.Vertices)-2].y;
                Normalize(v);
                v1:=v;
                v.x:=v1.x*coss-v1.y*sins;
                v.y:=v1.y*coss+v1.x*sins;
                v.x:=v.x/sins*GHeight;
                v.y:=v.y/sins*GHeight;
                if not GWidth then begin
                  tmp:=v1.x/v1.y/sqrt(sqr(v1.x/v1.y)+1);
                  v.x:=v.x*tmp;
                  v.y:=v.y*tmp;
                end;
                if v.x<0 then begin
                  v.x:=-v.x;
                  v.y:=-v.y;
                end;
                Pol.Vertices[High(Pol.Vertices)-1].x:=Pol.Vertices[High(Pol.Vertices)-2].x;
                Pol.Vertices[High(Pol.Vertices)-1].y:=Pol.Vertices[High(Pol.Vertices)-2].y-endheight-GHeight*0.01;
                Pol.Vertices[High(Pol.Vertices)-2].x:=Pol.Vertices[High(Pol.Vertices)-2].x+v.x;
                Pol.Vertices[High(Pol.Vertices)-2].y:=Pol.Vertices[High(Pol.Vertices)-2].y-endheight+v.y;

{                Pol.Vertices[High(Pol.Vertices)-1]:=Pol.Vertices[High(Pol.Vertices)-2];
                Pol.Vertices[High(Pol.Vertices)-1].y:=Pol.Vertices[High(Pol.Vertices)-1].y-GHeight*1.2;
                Pol.Vertices[High(Pol.Vertices)-2].x:=Pol.Vertices[High(Pol.Vertices)-2].x+0.2;}
              end;
              //---
              if not Modif then begin
                Modif:=true;
                Modified:=true;
              end;
              AddPolygon(Pol);
            end;
            SetLength(Pol.Vertices,0);
            IsCreating:=false;
          end;
        end else begin
          if not IsCreating then begin
            dec(i);
            IsCreating:=true;
            istart:=i+1;
          end;
        end;
        inc(i);
//        ALEForm.Caption:=IntToStr(Length(Vertices));
        i:=i mod l;
      until (i=maxx);
      Draw;
      State:=stReady;
    end;
  end;
end;

procedure TGrassTool.MouseDown(Shift: TShiftState; nx, ny: integer);
var
  p:TRPoint;
  nn,npol,tp:integer;
begin
  with Parent do begin
    p.x:=GetRX(nx);
    p.y:=GetRY(ny);
    WhatHere(p,npol,nn,tp);
    if (tp=tpVertex) or (tp=tpPolygon) then begin
      State:=stEdit;
      n:=npol;
    end;
  end;
end;

procedure TGrassTool.MouseMove(Shift: TShiftState; nx, ny: integer);
begin
  //
end;

procedure TGrassTool.MouseUp(Shift: TShiftState; nx, ny: integer);
begin
  //
end;

procedure TGrassTool.Setstate(const Value: integer);
begin
  Fstate := Value;
  if Fstate=stReady then begin
    AutoGrassForm.Hide;
  end else begin
    AutoGrassForm.Left:=ALEForm.Left+ALEForm.Width-AutoGrassForm.Width-20;
    AutoGrassForm.Top:=ALEForm.Top+130;
    AutoGrassForm.Show;
  end;
end;

end.