{------------------------------------------------------------------------------}
{
   Unit Name: DrawObject
   Purpose  : Drawing objects and cointainer for drawing objects
   Author   : Vesa Lappalainen
   Date     : 10.2.2001
   Changed  :

   ToDo     :
}
{------------------------------------------------------------------------------}

unit DrawObject;

interface
uses graphics,classes,Windows;

type
  TPointObj = class
  private
    fx,fy:integer;
  public
    constructor Create(ix,iy:integer);
    property x:integer read fx write fx;
    property y:integer read fy write fy;
  end;

  TDrawingObject = class
  private
    FPen : TPen;
    FFilled : boolean;
    procedure SetPen(const Value: TPen);
  protected
    procedure SetBrush(canvas: TCanvas); virtual;
    procedure DrawOne(canvas:TCanvas); virtual;
  public
    procedure CheckSettings(canvas:TCanvas); virtual;
    constructor Create;  virtual;
    destructor Destroy; override;
    procedure StartPoint(canvas:TCanvas;x,y:integer); virtual;
    procedure AddPoint(canvas:TCanvas;x,y:integer); virtual;
    procedure EndPoint(canvas:TCanvas;x,y:integer); virtual;
    procedure Draw(canvas:TCanvas); virtual;

  published
    property Pen:TPen read FPen write SetPen;
    property Filled:boolean read FFilled write FFilled;
  end;

  TFreeLine = class(TDrawingObject)
  private
    list : TList;
    procedure Clear;
  public
    constructor Create; override;
    destructor Destroy; override;
    procedure StartPoint(canvas:TCanvas;x,y:integer); override;
    procedure AddPoint(canvas:TCanvas;x,y:integer); override;
    procedure EndPoint(canvas:TCanvas;x,y:integer); override;
    procedure Draw(canvas:TCanvas); override;
  end;

  TDragObject = class(TDrawingObject)
  private
    StartPt,EndPt : TPoint;
    dragging : boolean;
  protected
    procedure SetBrush(canvas: TCanvas); override;
  public
    procedure CheckSettings(canvas:TCanvas); override;
    procedure StartPoint(canvas:TCanvas;x,y:integer); override;
    procedure AddPoint(canvas:TCanvas;x,y:integer); override;
    procedure EndPoint(canvas:TCanvas;x,y:integer); override;
    procedure Draw(canvas:TCanvas); override;
  end;

  TLine = class(TDragObject)
  protected
    procedure DrawOne(canvas:TCanvas); override;
  end;

  TRectangle = class(TDragObject)
  protected
    procedure DrawOne(canvas:TCanvas); override;
  end;

  TEllipse = class(TDragObject)
  protected
    procedure DrawOne(canvas:TCanvas); override;
  end;

  TDrawingObjects = class(TDrawingObject)
  private
    list : TList;
    function GetLast: TDrawingObject;
  public
    function Pop: TDrawingObject;
    procedure Clear;
    constructor Create; override;
    destructor Destroy; override;
    procedure AddObject(obj:TDrawingObject); virtual;
    procedure Draw(canvas:TCanvas); override;
    property Last:TDrawingObject read GetLast;
  end;

  TExampleObjects = class(TDrawingObjects)
  private
    function GetCount: integer; virtual;
    function GetNewObject(const name: string): TDrawingObject; virtual;
    function GetTName(i: integer): string; virtual;
  public
    procedure FillList(st:TStrings); virtual;
    property Count : integer read GetCount;
    property TName[i:integer] : string read GetTName;
    property NewObject[const name:string]:TDrawingObject read GetNewObject;
  end;

var ExampleGObjects : TExampleObjects;

implementation
uses SysUtils;

{ TDrawingObject }

procedure TDrawingObject.AddPoint(canvas: TCanvas; x, y: integer);
begin

end;

procedure TDrawingObject.CheckSettings(canvas: TCanvas);
begin

end;

constructor TDrawingObject.Create;
begin
  FPen := TPen.Create;
end;

destructor TDrawingObject.Destroy;
begin
  Pen.Free;
end;

procedure TDrawingObject.Draw(canvas: TCanvas);
begin

end;

procedure TDrawingObject.DrawOne(canvas: TCanvas);
begin

end;

procedure TDrawingObject.EndPoint(canvas: TCanvas; x, y: integer);
begin

end;

procedure TDrawingObject.SetBrush(canvas: TCanvas);
begin

end;

procedure TDrawingObject.SetPen(const Value: TPen);
begin
  FPen := Value;
end;

procedure TDrawingObject.StartPoint(canvas: TCanvas; x, y: integer);
begin

end;

{ TFreeLine }

procedure TFreeLine.AddPoint(canvas: TCanvas; x, y: integer);
var pt : TPointObj;
begin
  pt := TPointObj.Create(x,y);
  Canvas.LineTo(x,y);
  list.Add(pt);
end;

constructor TFreeLine.Create;
begin
  inherited;
  list := TList.Create;
end;

destructor TFreeLine.Destroy;
begin
  Clear;
  list.Free;
  inherited;
end;

procedure TFreeLine.Draw(canvas: TCanvas);
var i:integer;  pt : TPointObj;
begin
  if list.Count = 0 then exit;
  canvas.Pen := Pen;
  pt := TPointObj(list[0]);
  canvas.MoveTo(pt.x,pt.y);
  for i:=1 to list.Count-1 do begin
    pt := list[i];
    canvas.LineTo(pt.x,pt.y);
  end;
end;

procedure TFreeLine.EndPoint(canvas: TCanvas; x, y: integer);
begin
  inherited;

end;

procedure TFreeLine.Clear;
var i:integer;  pt : TPointObj;
begin
  for i:=0 to list.count-1 do begin
    pt := list[i];
    pt.Free;
  end;
  list.Clear;  
end;

procedure TFreeLine.StartPoint(canvas: TCanvas; x, y: integer);
var pt : TPointObj;
begin
  inherited;
  Clear;
  pt := TPointObj.Create(x,y);
  canvas.Pen := Pen;
  canvas.MoveTo(x,y);
  list.Add(pt);
end;

{ TPointObj }

constructor TPointObj.Create(ix, iy: integer);
begin
  fx := ix;
  fy := iy;
end;

{ TDrawingObjects }

procedure TDrawingObjects.AddObject(obj: TDrawingObject);
begin
  if ( obj = nil ) then exit;
  list.Add(obj);
end;

procedure TDrawingObjects.Clear;
var i:integer;  pt : TDrawingObject;
begin
  for i:=0 to list.count-1 do begin
    pt := list[i];
    pt.Free;
  end;
  list.Clear;
end;

constructor TDrawingObjects.Create;
begin
  inherited;
  list := TList.Create;
end;

destructor TDrawingObjects.Destroy;
begin
  Clear;
  list.Free;
  inherited;
end;

procedure TDrawingObjects.Draw(canvas: TCanvas);
var i:integer;  pt : TDrawingObject;
begin
  if list.Count = 0 then exit;
  for i:=0 to list.Count-1 do begin
    pt := list[i];
    pt.Draw(canvas);
  end;
end;

function TDrawingObjects.GetLast: TDrawingObject;
begin
  Result := nil;
  if ( list.Count = 0 ) then exit;
  Result := list[list.Count-1];
end;

function TDrawingObjects.Pop : TDrawingObject;
begin
  Result := nil;
  if list.Count = 0 then exit;
  Result := list[list.Count-1];
  list.Delete(list.Count-1);
end;

{ TDragObject }

procedure TDragObject.AddPoint(canvas: TCanvas; x, y: integer);
begin
  DrawOne(canvas);
  EndPt.x := x;
  EndPt.y := y;
  DrawOne(canvas);
end;

procedure TDragObject.SetBrush(canvas: TCanvas);
begin
  canvas.Pen := Pen;
  if ( dragging ) then
    canvas.Pen.Mode := pmNotXor;
  if ( filled ) then begin
    canvas.Brush.Color := Pen.Color;
    canvas.Brush.Style := bsSolid;
  end else
    canvas.Brush.Style := bsClear;
end;

procedure TDragObject.Draw(canvas: TCanvas);
begin
  SetBrush(canvas);
  DrawOne(canvas);
end;


procedure TDragObject.EndPoint(canvas: TCanvas; x, y: integer);
begin
  DrawOne(canvas);
  dragging := false;
  EndPt.x := x;
  EndPt.y := y;
  canvas.Pen := Pen;
  Draw(canvas);
end;

procedure TDragObject.StartPoint(canvas: TCanvas; x, y: integer);
begin
  dragging := true;
  SetBrush(canvas);
  StartPt.x := x;
  StartPt.y := y;
  EndPt := StartPt;
  DrawOne(canvas);
end;

procedure TDragObject.CheckSettings(canvas:TCanvas);
begin
  if ( dragging ) then DrawOne(canvas);
  SetBrush(canvas);
  if ( dragging ) then DrawOne(canvas);
end;

{ TLine }

procedure TLine.DrawOne(canvas: TCanvas);
begin
  canvas.MoveTo(StartPt.x,StartPt.y);
  canvas.LineTo(EndPt.x,EndPt.y);
end;

{ TRectangle }

procedure TRectangle.DrawOne(canvas: TCanvas);
begin
  canvas.Rectangle(StartPt.x,StartPt.y,EndPt.x,EndPt.y);
end;

{ TDragEllipse }

procedure TEllipse.DrawOne(canvas: TCanvas);
begin
  canvas.Ellipse(StartPt.x,StartPt.y,EndPt.x,EndPt.y);
end;

{ TExampleObjects }

procedure TExampleObjects.FillList(st: TStrings);
var i:integer;
begin
  for i:=0 to Count-1 do 
    st.Add(TName[i]);
end;

function TExampleObjects.GetCount: integer;
begin
  Result := List.Count;
end;

function TExampleObjects.GetNewObject(const name: string): TDrawingObject;
var i:integer;  pt : TDrawingObject; n:string;
begin
  Result := nil;
  n := UpperCase(name);
  for i:=0 to Count-1 do begin
    if ( n = UpperCase(TName[i]) ) then begin
      pt := List[i];
      Result := TDrawingObject(pt.NewInstance);
      Result.Create;
      exit;
    end;
  end;
end;

function TExampleObjects.GetTName(i: integer): string;
var pt : TDrawingObject;
begin
  Result := '';
  if ( i < 0 ) or ( Count <= i ) then exit;
  pt := List[i];
  Result := Copy(pt.ClassName,2,100);
end;

initialization begin
  ExampleGObjects := TExampleObjects.Create;
  ExampleGObjects.AddObject(TFreeLine.Create);
  ExampleGObjects.AddObject(TLine.Create);
  ExampleGObjects.AddObject(TRectangle.Create);
  ExampleGObjects.AddObject(TEllipse.Create);
end;

finalization begin
  ExampleGObjects.Free;
end;



end.