Разработка программы-эмулятора электронных схемотехнических компонентов

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls, kpLogElement, StdCtrls, kpLogScheme, kpPipeline;
 
type
  TForm1 = class(TForm)
    Panel1: TPanel;
    Label2: TLabel;
    AnimCB: TCheckBox;
    s1CB: TCheckBox;
    s2CB: TCheckBox;
    s3CB: TCheckBox;
    s4CB: TCheckBox;
    t2CB: TCheckBox;
    t1CB: TCheckBox;
    Memo1: TMemo;
    Button1: TButton;
    s5CB: TCheckBox;
    t3CB: TCheckBox;
    t4CB: TCheckBox;
    t5CB: TCheckBox;
    t6CB: TCheckBox;
    procedure FormCreate(Sender: TObject);
    procedure s1CBClick(Sender: TObject);
    procedure kpLogScheme1Change(Sender: TObject);
    procedure AnimCBClick(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.DFM}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
   Memo1.Lines.Assign(kpLogScheme1.Scheme);
end;
 
procedure TForm1.s1CBClick(Sender: TObject);
var Name: string;
begin
   Name := 's' + IntToStr(TControl(Sender).Tag);
   kpLogScheme1.SourceStateByName[Name] := TCheckBox(Sender).Checked;
end;
 
procedure TForm1.kpLogScheme1Change(Sender: TObject);
begin
try
   t1CB.Checked := kpLogScheme1.TerminalStateByName['t1'];
   t2CB.Checked := kpLogScheme1.TerminalStateByName['t2'];
   t3CB.Checked := kpLogScheme1.TerminalStateByName['t3'];
   t4CB.Checked := kpLogScheme1.TerminalStateByName['t4'];
   t5CB.Checked := kpLogScheme1.TerminalStateByName['t5'];
   t6CB.Checked := kpLogScheme1.TerminalStateByName['t6'];
except end;
end;
 
procedure TForm1.AnimCBClick(Sender: TObject);
begin
   kpLogScheme1.Animate := AnimCB.Checked;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  kpLogScheme1.Scheme := Memo1.Lines;
end;
 
end.

unit kpLogScheme;
{
     TkpLogScheme - ëîãè÷åñêàÿ ñõåìà
 
     âåðñèÿ 1.0
     (c) Ê. Ïîëÿêîâ, 2003
 
     FIDO:   2:5030/542.251
     e-mail: [email]kpolyakov@mail.ru[/email]
     Web:    [url]http://kpolyakov.narod.ru[/url]
             [url]http://kpolyakov.newmail.ru[/url]
 
     Ñîäåðæèò òðóáîïðîâîä (TkpPipeline) è ëîãè÷åñêèå ýëåìåíòû (TkpLogElement)
 
     Îïèñàíèå ñõåìû ïðåäñòàâëÿåò ñîáîé íàáîð ñèìâîëüíûõ
     ñòðîê. Êàæäàÿ ñòðîêà îïèñûâàåò îäèí ýëåìåíò:
        s x y èìÿ_âõîäà    âõîä â òî÷êå (x,y)
        l äëèíà            çâåíî âëåâî
        ã äëèíà            çâåíî âïðàâî
        u äëèíà            çâåíî ââåðõ
        d äëèíà            çâåíî âíèç
        j èìÿ_óçëà         íîâûé óçåë â òåêóùåé ïîçèöèè êóðñîðà
        t èìÿ_âûõîäà       âûõîä â òåêóùåé ïîçèöèè êóðñîðà
        g èìÿ_óçëà         ïåðåéòè â óçåë
        @ èìÿ_ýëåìåíòà òèï_ýëåìåíòà íîìåð_âõîäà øèðèíà âûñîòà ÷èñëî_âõîäîâ ÷èñëî_âûõîäîâ
                           ñîçäàòü íîâûé ëîãè÷åñêèé ýëåìåíò è ïðèñîåäèíèòü
                           òåêóùóþ ëèíèþ ñâÿçè ê óêàçàííîìó âõîäó (ïî óìîë÷àíèþ -
                           êî âõîäó 1)
                           ìîæíî èñïîëüçîâàòü ñëåäóþùèå òèïû ýëåìåíòîâ:
                              not       ýëåìåíòü ÍÅ
                              and       ýëåìåíò È
                              or        ýëåìåíò ÈËÈ
                              xor       ýëåìåíò èñêëþ÷àþùåå ÈËÈ
                              imp       ýëåìåíò "èìïëèêàöèÿ"
                              eq        ýëåìåíò "ýêâèâàëåíòíîñòü"
                              hsum      ýëåìåíò ïîëóñóììàòîð
                              sum       ýëåìåíò ñóììàòîð
                              trig      ýëåìåíò RS-òðèããåð
                           øèðèíó è âûñîòó ìîæíî íå óêàçûâàòü, îíà áóäåò âçÿòà èç
                           ñâîéñòâ LogElWidth/LogElHeight
                           ÷èñëî âûõîäîâ è âûõîäîâ íàäî óêàçûâàòü òîëüêî äëÿ
                           íåñòàíäàðòíûõ ýëåìåíòîâ
        # èìÿ_ýëåìåíòà íîìåð_âõîäà
                           ïðîâåñòè ëèíèþ ñâÿçè êî âõîäó ëîãè÷åñêîãî ýëåìåíòà
                           (óãëîì, ñíà÷àëà ïî y, ïîòîì - ïî x)
        $ èìÿ_ýëåìåíòà íîìåð_âûõîäà
                           ïåðåéòè ê âûõîäó ëîãè÷åñêîãî ýëåìåíòà (ïî óìîë÷àíèþ
                           - ê âûõîäó 1)
 
     Äîïîëíèòåëüíûå ñâîéñòâà è ìåòîäû:
 
        Scheme: TStrings       îïèñàíèå ëîãè÷åñêîé ñõåìû
        LogElColor: TColor     öâåò ëîãè÷åñêîãî ýëåìåíòà
        LogElWidth: integer    øèðèíà ëîãè÷åñêîãî ýëåìåíòà
        LogElHeight: integer   âûñîòà ëîãè÷åñêîãî ýëåìåíòà
        LogElPicture: TPicture èçîáðàæåíèå ëîãè÷åñêîãî ýëåìåíòà
 
     Óíàñëåäîâàííûå îò TkpPipeline:
     
        Animate: Boolean     èñïîëüçîâàòü àíèìàöèþ èëè íåò
        Color: TColor        öâåò âîäû
        AltColor: TColor     öâåò ïðîìåæóòêîâ
        BkColor: TColor      öâåò ôîíà
        BkBitmap: TBitmap    ôîíîâûé ðèñóíîê
        JointColor: TColor   öâåò êîíòóðà óçëîâ
        TickLength: integer  äëèíà îòðåçêà ïðè àíèìàöèè
        PipeWidth: integer   øèðèíà òðóáû
        MapList: TStrings    îïèñàíèå òðóáîïðîâîäà
        Period: integer      èíòåðâàë äëÿ àíèìàöèè
        MoveStep: integer    øàã äâèæåíèÿ ïîòîêà çà 1 èíòåðâàë ïðè àíèìàöèè
        HasLabels: Boolean   ñòàâèòü ëè ìåòêè âõîäîâ è âûõîäîâ
        SourceState[Index: integer]: Boolean       ñîñòîÿíèå âõîäà (äà/íåò)
        TerminalState[Index: integer]: Boolean     ñîñòîÿíèå âûõîäà (äà/íåò)
        SourceStateByName[Name: string]: Boolean   ñîñòîÿíèå âõîäà ïî èìåíè
        TerminalStateByName[Name: string]: Boolean ñîñòîÿíèå âûõîäà ïî èìåíè
        SourceNames: TStrings   èìåíà âõîäîâ
        TerminalNames: TStrings èìåíà âûõîäîâ
        JointNames: TStrings    èìåíà óçëîâ
 
     Ñîáûòèÿ:
        OnChange: TNotifyEvent  èçìåíèëîñü ñîñòîÿíèå âõîäîâ, ìîãëî
                                (íî íå îáÿçàòåëüíî!) èçìåíèòüñÿ è ñîñòîÿíèå âûõîäîâ
                                
        OnProcessLine: TLineNotifyEvent
                                ñîáûòèå ïðè îáðàáîòêå ñòðîêè ñõåìû ñ óêàçàííûì íîìåðîì,
                                ìîæíî èñïîëüçîâàòü äëÿ ëîêàëèçàöèè îøèáîê
 
        OnCustomOp: TCustomOpEvent
                                íåîáõîäèìî ðàññ÷èòàòü ñîñòîÿíèÿ âûõîäîâ íåñòàíäàðòíîãî ýëåìåíòà
                                Ïàðàìåòðû
                                     sOldState - ñèìâîëüíàÿ öåïî÷êà íóëåé (#48) è åäèíèö (#49),
                                               îïðåäåëÿþùèõ ïðîøëîå ñîñòîÿíèå âûõîäîâ
                                     sInVal    - òàêàÿ æå öåïî÷êà, îïðåäåëÿþùàÿ
                                               òåêóùåå ñîñòîÿíèå âõîäîâ
                                 var sOutVal   - òàêàÿ æå öåïî÷êà äëÿ âûõîäîâ, êîòîðóþ
                                               äîëæíà ñîñòàâèòü ïðîöåäóðà.
}
 
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls, kpPipeline, kpLogElement;
 
type
  ELogSchemeError = class(Exception) end;
 
  TkpLogScheme = class(TkpPipeLine)
  private
    { Private declarations }
    FScheme: TStrings;
    FLogUnits: TStringList;
    FLogElPicture: TPicture;
    FLogElWidth, FLogElHeight: integer;
    FLogElColor: TColor;
    FOnProcessLine: TLineNotifyEvent;
    FOnCustomOp: TCustomOpEvent;
  protected
    { Protected declarations }
     procedure SetLogElWidth(NewWidth: integer);
     procedure SetLogElHeight(NewHeight: integer);
     procedure SetScheme ( NewScheme: TStrings );
     procedure SetLogElPicture(NewPicture: TPicture);
     function  GetBevelInner: TPanelBevel;
     procedure SetBevelInner(Value: TPanelBevel);
     function  GetBevelOuter: TPanelBevel;
     procedure SetBevelOuter(Value: TPanelBevel);
     function  GetBevelWidth: integer;
     procedure SetBevelWidth(Value: integer);
     function  GetBorderWidth: integer;
     procedure SetBorderWidth(Value: integer);
     procedure SetOnCustomOp(Value: TCustomOpEvent);
     procedure SetLogElColor(Value: TColor);
     procedure ClearLogUnitList;
     procedure BuildScheme;
     procedure Loaded; override;
     procedure RedrawAll; override;
     procedure HookProcessLine(Sender: TObject; LineNo: integer);
  public
    { Public declarations }
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
  published
    { Published declarations }
    property BevelInner: TPanelBevel read GetBevelInner write SetBevelInner;
    property BevelOuter: TPanelBevel read GetBevelOuter write SetBevelOuter;
    property BevelWidth: integer read GetBevelWidth write SetBevelWidth;
    property BorderWidth: integer read GetBorderWidth write SetBorderWidth;
    property LogElColor: TColor read FLogElCOlor write SetLogElColor;
    property LogElWidth: integer read FLogElWidth write SetLogElWidth;
    property LogElHeight: integer read FLogElHeight write SetLogElHeight;
    property LogElPicture: TPicture read FLogElPicture write SetLogElPicture;
    property Scheme: TStrings read FScheme write SetScheme;
    property OnProcessLine: TLineNotifyEvent read FOnProcessLine write FOnProcessLine;
    property OnCustomOp: TCustomOpEvent read FOnCustomOp write SetOnCustomOp;
  end;
 
procedure Register;
 
implementation
 
uses DesignIntf;
 
//----------- constructor -----------
constructor TkpLogScheme.Create(AOwner: TComponent);
begin
   inherited;
   inherited OnProcessLine := HookProcessLine;
   FLogUnits := TStringList.Create;
   FScheme := TStringList.Create;
   FLogElColor := clWhite;
   FLogElWidth := 40;
   FLogElHeight := 50;
   FLogElPicture := TPicture.Create;
end;
 
//----------- destructor -----------
destructor TkpLogScheme.Destroy;
begin
  ClearLogUnitList;
  FLogUnits.Free;
  FScheme.Free;
  FLogElPicture.Free;
  inherited;
end;
 
//----------- HookProcessLine -----------
procedure TkpLogScheme.HookProcessLine(Sender: TObject; LineNo: integer);
begin
   LineNo := integer(MapList.Objects[LineNo]);
   if Assigned(FOnProcessLine) then FOnProcessLine(Self, LineNo);
end;
 
//----------- Loaded -----------
procedure TkpLogScheme.Loaded;
begin
   inherited;  
   BuildScheme;
   RedrawAll;
end;
 
//----------- SetScheme -----------
procedure TkpLogScheme.SetScheme ( NewScheme: TStrings );
begin
   if not Assigned(NewScheme) then
        FScheme.Clear
   else FScheme.Assign(NewScheme);
   BuildScheme;
   RedrawAll;
end;
 
//-------------- RedrawAll ------------------
procedure TkpLogScheme.RedrawAll;
var i: integer;
    LE: TkpLogElement;
begin
   inherited;
   for i:=0 to ControlCount-1 do
     if Controls[i] is TkpLogElement then begin
        LE := TkpLogElement(Controls[i]);
        LE.Paint;
     end;
end;
 
//----------- BuildScheme -----------
procedure TkpLogScheme.BuildScheme;
var i, x, y, nSource, nTerminal: integer;
    NeedSource, AfterUnit: Boolean;
    Joints: TStringList;
    s: string;
    Dir: char;
  //---------- GetWord ------------------------
  function GetWord(var s: string): string;
  var p: integer;
  begin
    s := Trim(s);
    p := Pos(' ', s);
    if p = 0 then begin Result := s; s := ''; end
    else begin          Result := Copy(s, 1, p-1); s := Copy(s, p+1, 999); end;
  end;
  //---------- Unpack New Unit ------------------------
  procedure UnPackNewUnit(s: string);
  var ElName, sKind: string;
      nIn, xWidth, xHeight, InCount, OutCount: integer;
      Obj: TkpLogElement;
  begin
    ElName := AnsiLowerCase(GetWord(s));
    if ElName = '' then
       raise ELogSchemeError.Create('Íå çàäàíî èìÿ ëîãè÷åñêîãî ýëåìåíòà');
    if FLogUnits.IndexOf(ElName) >= 0 then
       raise ELogSchemeError.CreateFmt('Ëîãè÷åñêèé ýëåìåíò ñ èìåíåì ''%s'' óæå åñòü', [ElName]);
    sKind := AnsiLowerCase(GetWord(s));
{    if (sKind <> 'not') and  (sKind <> 'and') and  (sKind <> 'or') and
       (sKind <> 'xor') and  (sKind <> 'imp') and  (sKind <> 'eq') and
       (sKind <> 'hsum') and  (sKind <> 'sum') and  (sKind <> 'trig') then
       raise ELogSchemeError.CreateFmt('Íåèçâåñòíûé òèï ýëåìåíòà ''%s''', [sKind]); }
    nIn := StrToIntDef(GetWord(s), 1);
    xWidth := StrToIntDef(GetWord(s), 0);
    xHeight := StrToIntDef(GetWord(s), 0);
    InCount := StrToIntDef(GetWord(s), 2);
    OutCount := StrToIntDef(GetWord(s), 1);
    Obj := TkpLogElement.Create(nil);
    with Obj do begin
       Locked := True;
       if sKind = 'not'  then Kind := leNot  else
       if sKind = 'and'  then Kind := leAnd  else
       if sKind = 'or'   then Kind := leOr   else
       if sKind = 'xor'  then Kind := leXor  else
       if sKind = 'imp'  then Kind := leImp  else
       if sKind = 'eq'   then Kind := leEq   else
       if sKind = 'hsum' then Kind := leHSum else
       if sKind = 'sum'  then Kind := leSum  else
       if sKind = 'trig' then Kind := leTrig else Kind := leCustom;
       if Kind = leCustom then begin
          Caption := ElName;
          InputCount := InCount;
          OutputCount := OutCount;
       end;
       InsertControl(Obj);
       if xWidth > 0 then  Width := xWidth   else Width := FLogElWidth;
       if xHeight > 0 then Height := xHeight else Height := FLogElHeight;
       Left := x + Margin - 1;
       Top := y - Obj.InputCoord[nIn] + Margin;
       Color := Self.LogElColor;
       BkColor := Self.BkColor;
       BkBitmap := Self.BkBitmap;
       InPipes := Self;
       OutPipes := Self;
       Picture := FLogElPicture;
       OnCustomOp := FOnCustomOp;
       s := StringOfChar('0', InputCount);
       s[nIn] := Char(nTerminal+1 + Ord('0')); // nterminal will be increased later!
       InIndices := s;
       OutIndices := StringOfChar('0', OutputCount);
       Locked := False;
    end;
    FLogUnits.AddObject(ElName, Obj);
    x := x + FLogElWidth;
    y := Obj.Top + Obj.OutputCoord[1] - Margin;
  end;
  //---------- GoToUnitInput ------------------------
  procedure GoToUnitInput(s: string);
  var ElName: string;
      j, n, nIn, x0, y0: integer;
      Obj: TkpLogElement;
  begin
    ElName := AnsiLowerCase(GetWord(s));
    n := FLogUnits.IndexOf(ElName);
    if n < 0 then
       raise ELogSchemeError.CreateFmt('Íå íàéäåí ýëåìåíò ñ èìåíåì ''%s''', [ElName]);
    Obj := TkpLogElement(FLogUnits.Objects[n]);
    Obj.Locked := True;
    nIn := StrToIntDef(GetWord(s), 1);
    if (nIn < 1) or (nIn > Obj.InputCount) then
       raise ELogSchemeError.CreateFmt('Íå íàéäåí âõîä íîìåð %d', [nIn]);
    x0 := Obj.Left - Margin;
    y0 := Obj.Top + Obj.InputCoord[nIn] - Margin;
    j := i+1;
    if y0 < y then begin MapList.Insert(j, Format('u %d', [y-y0])); Inc(j); end;
    if y0 > y then begin MapList.Insert(j, Format('d %d', [y0-y])); Inc(j); end;
    if x0 < x then begin MapList.Insert(j, Format('l %d', [x-x0])); Inc(j); end;
    if x0 > x then begin MapList.Insert(j, Format('r %d', [x0-x])); Inc(j); end;
    MapList.Insert(j, 't');
    s := Obj.InIndices;
    s[nIn] := Char(nTerminal+1 + Ord('0'));
    Obj.InIndices := s;
    Obj.Locked := False;
  end;
  //---------- StartFromUnitOutput ------------------------
  procedure StartFromUnitOutput(s: string);
  var ElName: string;
      n, nOut: integer;
      Obj: TkpLogElement;
  begin
    ElName := AnsiLowerCase(GetWord(s));
    n := FLogUnits.IndexOf(ElName);
    if n < 0 then
       raise ELogSchemeError.CreateFmt('Íå íàéäåí ýëåìåíò ñ èìåíåì ''%s''', [ElName]);
    Obj := TkpLogElement(FLogUnits.Objects[n]);
    Obj.Locked := True;
    nOut := StrToIntDef(GetWord(s), 1);
    if (nOut < 1) or (nOut > Obj.OutputCount) then
       raise ELogSchemeError.CreateFmt('Íå íàéäåí âûõîä íîìåð %d', [nOut]);
    x := Obj.Left + Obj.Width - Margin;
    y := Obj.Top + Obj.OutputCoord[nOut] - Margin;
    s := Obj.OutIndices;
    s[nOut] := Char(nSource+1 + Ord('0'));
    Obj.OutIndices := s;
    Obj.Locked := False;
  end;
  //------------- MOVE POINT ---------------------------------------
  procedure MovePoint ( Dir: char; s: string );
  var p, n1, n2: integer;
  begin
    s := Trim(s);
    p := Pos(' ', s); if p = 0 then p := Length(s)+1;
    n1 := StrToIntDef(Copy(s,1,p-1), 0);
    Delete(s, 1, p);
    p := Pos(' ', s); if p = 0 then p := Length(s)+1;
    n2 := StrToIntDef(Copy(s,1,p-1), 0);
    case Dir of
       's': begin
            if not NeedSource then
               raise ELogSchemeError.Create('Èñòî÷íèê â íåîæèäàííîì ìåñòå!');
            x := n1; y := n2;
            Inc(nSource);
            end;
       'u': begin y := y - n1; end;
       'd': begin y := y + n1; end;
       'l': begin x := x - n1; end;
       'r': begin x := x + n1; end;
    end;
  end;
  //------------- GoToJoint -----------------------------
  procedure GoToJoint ( s: string );
  var n, xy: integer;
  begin
    if not NeedSource then raise ELogSchemeError.Create('Ïåðåõîä â íåîæèäàííîì ìåñòå!');
    n := Joints.IndexOf ( s );
    if n < 0 then raise ELogSchemeError.CreateFmt('Íåèçâåñòíûé óçåë ''%s''', [s]);
    xy := integer(Joints.Objects[n]);
    x := xy div 10000;
    y := xy mod 10000;
  end;
  //----------------------------------------------------
begin
   Joints := TStringList.Create;
 
   MapList.Assign(FScheme);
   for i:=0 to MapList.Count-1 do
       MapList.Objects[i] := TObject(i);
 
try
   ClearLogUnitList;
   NeedSource := True;
   i := 0; x := -1; y := -1;
   nSource := - 1;
   nTerminal := - 1;
   AfterUnit := False;
 
   while i < MapList.Count do begin
 
     s := Trim(MapList[i]);
     if s = '' then begin
        MapList.Delete(i);
        continue;
     end;
 
     Dir := s[1];
     Delete(s, 1, 1);
     s := AnsiLowerCase(Trim(s));
 
     case Dir of
        's', 'u', 'd', 'l', 'r':
             begin
             if NeedSource and (Dir <> 's') then begin
               MapList.Insert(i, Format('s %d %d', [x,y]));
               Dec(i);
               if AfterUnit then
                  StartFromUnitOutput(FLogUnits[FLogUnits.Count-1]);
             end
             else begin
               MovePoint ( Dir, s );
               NeedSource := False;
             end;
             AfterUnit := False;
             end;
        'j': begin
             Joints.AddObject(s, TObject(x*10000+y));
             NeedSource := False;
             AfterUnit := False;
             end;
        'g': begin
             GoToJoint(s);
             NeedSource := False;
             AfterUnit := False;
             end;
        't': begin
             NeedSource := True;
             Inc(nTerminal);
             end;
        '@': begin
             UnPackNewUnit ( s );
             MapList.Delete(i);
             MapList.Insert(i, 't');
             NeedSource := False;
             AfterUnit := True;
             Dec(i);
             end;
        '#': begin
             GoToUnitInput ( s );
             MapList.Delete(i);
             NeedSource := False;
             AfterUnit := False;
             Dec(i);
             end;
        '$': begin
             StartFromUnitOutput ( s );
             MapList.Delete(i);
             MapList.Insert(i, Format('s %d %d', [x,y]));
             NeedSource := True;
             AfterUnit := False;
             Dec(i);
             end;
     end;
     Inc(i);
   end;
 
   BuildPipeline;
 
finally
   Joints.Free;
end;
 
end;
 
//----------- ClearLogUnitList -----------
procedure TkpLogScheme.ClearLogUnitList;
var Obj: TkpLogElement;
begin
  while FLogUnits.Count > 0 do begin
     Obj := TkpLogElement(FLogUnits.Objects[0]);
     RemoveControl(Obj);
     Notification(Obj, opRemove);
     Obj.Free;
     FLogUnits.Delete(0);
  end;
end;
 
//-------------- SetLogElPicture ------------------
procedure TkpLogScheme.SetLogElPicture(NewPicture: TPicture);
begin
   FLogElPicture.Assign(NewPicture);
   BuildScheme;
   RedrawAll;
end;
 
//-------------- SetLogElWidth ------------------
procedure TkpLogScheme.SetLogElWidth(NewWidth: integer);
begin
   if NewWidth < 1 then NewWidth := 1;
   if NewWidth > 400 then NewWidth := 400;
   if FLogElWidth = NewWidth then Exit;
   FLogElWidth := NewWidth;
   BuildScheme;
   RedrawAll;
end;
 
//-------------- SetLogElHeight ------------------
procedure TkpLogScheme.SetLogElHeight(NewHeight: integer);
begin
   if NewHeight < 1 then NewHeight := 1;
   if NewHeight > 400 then NewHeight := 400;
   if FLogElHeight = NewHeight then Exit;
   FLogElHeight := NewHeight;
   BuildScheme;
   RedrawAll;
end;
 
//-------------- BevelInner -------------------------
function  TkpLogScheme.GetBevelInner: TPanelBevel;
begin Result := inherited BevelInner; end;
procedure TkpLogScheme.SetBevelInner(Value: TPanelBevel);
begin
   if inherited BevelInner <> Value then begin
      inherited BevelInner := Value;
      BuildScheme;
      RedrawAll;
   end;
end;
 
//-------------- BevelOuter -------------------------
function  TkpLogScheme.GetBevelOuter: TPanelBevel;
begin Result := inherited BevelOuter; end;
procedure TkpLogScheme.SetBevelOuter(Value: TPanelBevel);
begin
   if inherited BevelOuter <> Value then begin
      inherited BevelOuter := Value;
      BuildScheme;
      RedrawAll;
   end;
end;
 
//-------------- BevelWidth -------------------------
function  TkpLogScheme.GetBevelWidth: integer;
begin Result := inherited BevelWidth; end;
procedure TkpLogScheme.SetBevelWidth(Value: integer);
begin
   if inherited BevelWidth <> Value then begin
      inherited BevelWidth := Value;
      BuildScheme;
      RedrawAll;
   end;
end;
 
//-------------- BorderWidth -------------------------
function  TkpLogScheme.GetBorderWidth: integer;
begin Result := inherited BorderWidth; end;
procedure TkpLogScheme.SetBorderWidth(Value: integer);
begin
   if inherited BorderWidth <> Value then begin
      inherited BorderWidth := Value;
      BuildScheme;
      RedrawAll;
   end;
end;
 
//-------------- SetOnCustomOp -----------------------
procedure TkpLogScheme.SetOnCustomOp(Value: TCustomOpEvent);
var i: integer;
    LE: TkpLogElement;
begin
   FOnCustomOp := Value;
   for i:=0 to ControlCount-1 do
     if Controls[i] is TkpLogElement then begin
        LE := TkpLogElement(Controls[i]);
        LE.OnCustomOp := Value;
     end;
end;
 
//---------------- SetLogElCOlor ---------------
procedure TkpLogScheme.SetLogElColor(Value: TColor);
var i: integer;
    LE: TkpLogElement;
begin
   if FLogElColor = Value then Exit;
   FLogElColor := Value;
   for i:=0 to ControlCount-1 do
     if Controls[i] is TkpLogElement then begin
        LE := TkpLogElement(Controls[i]);
        LE.Color := Value;
     end;
end;
 
//---------------- REGISTER ---------------------------
procedure Register;
begin
  RegisterComponents('KP', [TkpLogScheme]);
  RegisterPropertyEditor(TypeInfo(TStrings), TkpLogScheme, 'MapList', nil);
end;
 
end.