source: branches/Xvcl/Xvcl.Classes.pas

unit Xvcl.Classes;

interface

type
  TPoint = record
    X: Integer;
    Y: Integer;
    constructor Create(X, Y: Integer);
    function Add(Point: TPoint): TPoint;
    function Substract(Point: TPoint): TPoint;
    function IsZero: Boolean;
    class operator Add(A, B: TPoint): TPoint;
    class operator Subtract(A, B: TPoint): TPoint;
  end;

  TRectangle = record
  private
    function GetBottom: Integer;
    function GetPosition: TPoint;
    function GetRight: Integer;
    function GetSize: TPoint;
    function GetBottomLeft: TPoint;
    function GetBottomRight: TPoint;
    function GetTopLeft: TPoint;
    function GetTopRight: TPoint;
    procedure SetTopLeft(const Value: TPoint);
    procedure SetBottomRight(const Value: TPoint);
    procedure SetBottom(const Value: Integer);
    procedure SetRight(const Value: Integer);
    procedure SetTopRight(const Value: TPoint);
  public
    Left: Integer;
    Top: Integer;
    Width: Integer;
    Height: Integer;
    property Right: Integer read GetRight write SetRight;
    property Bottom: Integer read GetBottom write SetBottom;
    property Size: TPoint read GetSize;
    property Position: TPoint read GetPosition;
    property TopLeft: TPoint read GetTopLeft write SetTopLeft;
    property BottomRight: TPoint read GetBottomRight write SetBottomRight;
    property TopRight: TPoint read GetTopRight write SetTopRight;
    property BottomLeft: TPoint read GetBottomLeft;
    constructor Create(Left, Top, Width, Height: Integer);
    function Contains(Position: TPoint): Boolean;
  end;

  TComponent = class
  private
    FOwner: TComponent;
    FName: string;
  public
    constructor Create; virtual;
    property Owner: TComponent read FOwner write FOwner;
    property Name: string read FName write FName;
  end;

  TNotifyEvent = procedure (Sender: TObject) of object;

  TUpdateLock = class
  private
    FOnUpdate: TNotifyEvent;
  published
    Counter: Integer;
    procedure Start;
    procedure Stop;
    procedure Update;
    property OnUpdate: TNotifyEvent read FOnUpdate write FOnUpdate;
  end;


implementation

{ TBounds }

function TRectangle.Contains(Position: TPoint): Boolean;
begin
  Result := (Position.X >= Left) and (Position.X < Right) and (Position.Y >= Top)
    and (Position.Y < Bottom);
end;

constructor TRectangle.Create(Left, Top, Width, Height: Integer);
begin
  Self.Left := Left;
  Self.Top := Top;
  Self.Width := Width;
  Self.Height := Height;
end;

function TRectangle.GetBottom: Integer;
begin
  Result := Top + Height;
end;

function TRectangle.GetBottomLeft: TPoint;
begin
  Result := TPoint.Create(Left, Bottom);
end;

function TRectangle.GetBottomRight: TPoint;
begin
  Result := TPoint.Create(Right, Bottom);
end;

function TRectangle.GetTopLeft: TPoint;
begin
  Result := TPoint.Create(Left, Top);
end;

function TRectangle.GetPosition: TPoint;
begin
  Result := TPoint.Create(Left, Top);
end;

function TRectangle.GetRight: Integer;
begin
  Result := Left + Width;
end;

function TRectangle.GetTopRight: TPoint;
begin
  Result := TPoint.Create(Right, Top);
end;

procedure TRectangle.SetBottom(const Value: Integer);
begin
  Height := Value - Top;
end;

procedure TRectangle.SetBottomRight(const Value: TPoint);
begin
  Right := Value.X;
  Bottom := Value.Y;
end;

procedure TRectangle.SetRight(const Value: Integer);
begin
  Width := Value - Left;
end;

procedure TRectangle.SetTopLeft(const Value: TPoint);
begin
  Left := Value.X;
  Top := Value.Y;
end;

procedure TRectangle.SetTopRight(const Value: TPoint);
begin
  Top := Value.X;
  Right := Value.Y;
end;

function TRectangle.GetSize: TPoint;
begin
  Result := TPoint.Create(Width, Height);
end;

{ TComponent }

constructor TComponent.Create;
begin
end;

{ TPoint }

function TPoint.Add(Point: TPoint): TPoint;
begin
  Result := TPoint.Create(X + Point.X, Y + Point.Y);
end;

class operator TPoint.Add(A, B: TPoint): TPoint;
begin
  Result.X := A.X + B.X;
  Result.Y := A.Y + B.Y;
end;

constructor TPoint.Create(X, Y: Integer);
begin
  Self.X := X;
  Self.Y := Y;
end;


function TPoint.IsZero: Boolean;
begin
  Result := (X = 0) and (Y = 0);
end;

class operator TPoint.Subtract(A, B: TPoint): TPoint;
begin
  Result.X := A.X - B.X;
  Result.Y := A.Y - B.Y;
end;

function TPoint.Substract(Point: TPoint): TPoint;
begin
  Result := TPoint.Create(X - Point.X, Y - Point.Y);
end;

{ TUpdateLock }

procedure TUpdateLock.Start;
begin
  Inc(Counter);
end;

procedure TUpdateLock.Stop;
begin
  if Counter > 0 then begin
    Dec(Counter);
    Update;
  end;
end;

procedure TUpdateLock.Update;
begin
  if (Counter = 0) and Assigned(FOnUpdate) then
    FOnUpdate(Self);
end;

end.