TOPIC:

interface

type

  Float = single;

  TSample = Float;
  PSample = ^TSample;

  TPtArray = array of Float;

  { TScopeChanel }

  TScopeChanel = class(TCollectionItem)
  public
     constructor Create(aCollect : TCollection); override;
     destructor Destroy; override;
     procedure SetData(Samples : PSample; Count : integer; ChanelCount : integer = 1);
     procedure Assign(Source: TPersistent); override;
  private
    FColor: TColor;
    FMultY: Float;
    FName: string;
    FOffsY: Float;
    FTitle: string;
    FUnitName: string;
    FWidth: Float;
    FPoints : TPtArray;
    function GetPoint(I : integer): Float;
    procedure SetColor(AValue: TColor);
    procedure SetMultY(AValue: Float);
    procedure SetOffsY(AValue: Float);
    procedure SetTitle(AValue: string);
    procedure SetUnitName(AValue: string);
    procedure SetWidth(AValue: Float);
    procedure Notify;
  published
     property Title : string read FTitle write SetTitle;
     property UnitName : string read FUnitName write SetUnitName;
     property Color : TColor read FColor write SetColor;
     property Width : Float read FWidth write SetWidth;
     property OffsY : Float read FOffsY write SetOffsY;
     property UnitPerDivY : Float read FMultY write SetMultY;
  public
     property Point[I : integer] : Float read GetPoint; default;
  end;

  { TChanelCollection }

  TScope = class;

  TChanelCollection = class(TCollection)
  private
    FScope: TScope;
    function GetItems(Index: integer): TScopeChanel;
    procedure SetItems(Index: integer; AValue: TScopeChanel);
  public
    constructor Create(aScope : TScope);
  public
    function Add: TScopeChanel;
    property Items[Index: integer]: TScopeChanel read GetItems write SetItems; default;
    property Scope : TScope read FScope;
  end;

TScope = class(TCustomControl)
     .....  bla-bla-bla ......
published
     .....  bla-bla-bla ......
     property Chanels : TChanelCollection read FChanels write SetChanels;
  end;

implementation
uses
  BGRAPen, Math;

function DesignTime(Comp : TComponent): boolean;
   function PresentedAttrs(Atr : TComponentState) : boolean;
   begin
      Result := (Comp.ComponentState * Atr) = Atr;
   end;
begin
  Result := PresentedAttrs([csDesigning]);
end;

{ TScopeChanel }
var
  ScopeChanelNum : integer;
const
  ScopeColor : array[0..15] of TColor =
    (clYellow, clRed, clBlue, clGreen,
     clMoneyGreen, clPurple, clNavy, clLime,
     clLime, clCream, clMaroon, clOlive,
     clTeal, clAqua, clSkyBlue, clFuchsia
    );

constructor TScopeChanel.Create(aCollect: TCollection);
begin
  inherited Create(aCollect);
  FColor := ScopeColor[ScopeChanelNum mod 16];
  FMultY := 1;
  FOffsY := 0;
  ScopeChanelNum += 1;
  FTitle := 'ScopeChanel' + IntToStr(ScopeChanelNum);
  FWidth := 1;
end;

destructor TScopeChanel.Destroy;
begin
  SetLength(FPoints, 0);
  inherited Destroy;
end;

procedure TScopeChanel.SetData(Samples: PSample; Count: integer;
  ChanelCount: integer);
var
  i : integer;
begin
  SetLength(FPoints, Count);
  for i := 0 to Count-1 do begin
     FPoints[i] := Samples[i * ChanelCount];
  end;
end;

procedure TScopeChanel.Assign(Source: TPersistent);
begin
  inherited Assign(Source);
  if Source is TScopeChanel then begin
     UnitPerDivY := TScopeChanel(Source).UnitPerDivY;
     Color := TScopeChanel(Source).Color;
     OffsY := TScopeChanel(Source).OffsY;
     Title := TScopeChanel(Source).Title;
     Width := TScopeChanel(Source).Width;
  end;
end;

function TScopeChanel.GetPoint(I: integer): Float;
begin
  if Index >= length(FPoints) then
     raise Exception.Create('Invalid point number for '+FName);
  Result := FPoints[i] + FOffsY;
end;

procedure TScopeChanel.SetColor(AValue: TColor);
begin
  if FColor=AValue then Exit;
  FColor:=AValue;
  Notify;
end;

procedure TScopeChanel.SetMultY(AValue: Float);
begin
  if FMultY=AValue then Exit;
  FMultY:=AValue;
  Notify;
end;

procedure TScopeChanel.SetOffsY(AValue: Float);
begin
  if FOffsY=AValue then Exit;
  FOffsY:=AValue;
  Notify;
end;

procedure TScopeChanel.SetTitle(AValue: string);
begin
  if FTitle=AValue then Exit;
  FTitle:=AValue;
  Notify;
end;

procedure TScopeChanel.SetUnitName(AValue: string);
begin
  if FUnitName=AValue then Exit;
  FUnitName:=AValue;
  Notify;
end;

procedure TScopeChanel.SetWidth(AValue: Float);
begin
  if FWidth=AValue then Exit;
  FWidth:=AValue;
  Notify;
end;

procedure TScopeChanel.Notify;
begin
  Changed(false);
  TChanelCollection(Collection).Scope.ReDraw;
end;

{ TChanelCollection }

function TChanelCollection.GetItems(Index: integer): TScopeChanel;
begin
   Result := TScopeChanel(inherited Items[Index]);
end;

procedure TChanelCollection.SetItems(Index: integer; AValue: TScopeChanel);
begin
  inherited Items[Index].Assign(AValue);
end;

constructor TChanelCollection.Create(aScope: TScope);
begin
   inherited Create(TScopeChanel);
   FScope := aScope;
end;

function TChanelCollection.Add: TScopeChanel;
begin
   Result := inherited Add as TScopeChanel;
end;[/i][/i]