Komponente wird installiert aber RTL100.Bpl-Fehler

[BAMatze]

Hallo und guten Morgen an alle DP´ler,

Ich hab nach den gesterigen doch etwas häufigeren Fragen wegen dem "richtigen" packen einer Komponente in ein Package, meine Komponente erfolgreich installieren können. Sie lief gestern auch gut 20min fast Fehlerfrei, bis ich dann den neusten Stand des Quellcodes in diese reinpacken wollte. Habe also Komponente installiert und die Pas im Package (und Datei im Ordner) ersetzt. Nach Neuinstallation, liegt die Komponente zwar in der Toolbar, aber wenn ich sie auf die Form ziehen möchte, bekomme ich eine Zugriffsverletzung in der RTL100.Bpl.
Ich habe hier gelesen, dass dies meist dann auftritt, wenn bpl, dcu, ... nicht am richtigen Platz liegen. Meiner Meinung nach habe ich doch aber durch den Austausch nichts an diesen geändert (vieleicht an der dcu aber mehr auch nicht).

Kann mir vieleicht jemand sagen, woran das liegt?

Vielen Dank
BAMatze

[BAMatze]

Ok ich schreibe einfach mal was ich schon alles gemacht hab, vieleicht kennt ja jemand den Fehler und kann mir vieleicht mal einen Tip geben, ob ich irgendwo etwas vernachlässige.

Hab folgende Links gefunden:

RTL100.bpl-Fehler bei Komponente D5 -> 2006 Hier wurde das Problem per Umbenennung des Packages behoben. Gleiches viel bei mir negativ aus.

Hier kommen zwar auch Fehler bei rtl100.bpl vor aber nicht in meiner Form Konnte ich nicht verwenden. Gibt aber etliche ähnliche Bsp´s hier.

Owner und Parent beachten Habe das create aller Komponenten auf oki´s Hinweis von gestern auf nil und den Parent auf Self gesetzt. Hat gestern so in einer älteren Quellcode-Version funktioniert. Beim neuen Quellcode ändert dies nichts.

eine Art Checkliste für eigene Komponenten Hier habe ich mal alle Dateitypen kontrolliert, ob sie da liegen, wo auch die Dateien anderer funktionierender Packages liegen. Ist so der Fall, also Ja.

weiterer Link Also der letzt Beitrag hier beantwortet mir zumindest ein paar meiner Fragen, z.B. hat die rtl100.bpl was mit dem Speicher zu tun. Der Fehler scheinen bei der Erstellung auch nicht immer einfach erkennbare Lösungen zu haben. Was mir etwas Hoffnung macht, weil ich dann vieleicht nicht doch zu dumm bin und warscheinlich nur die Möglichkeit für Hilfestellung verringert

Tja gab noch einige Bsp´s hier aber die scheinen sich zumindest zu ähneln, einige hören vor der bekanntgabe einer Lösung auf. Hab auch mal beim Google´n so ne Anleitung für die Erstellung gefunden mit Schritt für Schrittanleitung und daran liegt es auch nicht.

Quellcode werde ich gleich nochmal posten (also den neuen) hab gelesen, dass es eventuell daran liegen kann, dass "ungünstiger" Code verwendet wird (z.B. bei create und Parent). Lasse nur gerade die Reperatur an Delphi vornehmen, damit ich dieses als Fehlerquelle auch ausklammern kann.

MfG
BAMatze

[BAMatze]

Also auch das Reparieren von Delphi blieb ohne Erfolg. Deswegen hier mal der Quellcode der Komponente, die ich erzeugen möchte. Vieleicht sieht jemand ja den Fehler.

Delphi-Quellcode:

unit CompositeControlUnit;

interface

uses Controls, StdCtrls, Windows, Forms, Graphics, Classes, ComCtrls, SysUtils, Dialogs,
     ExtCtrls, ZahlEdit, MouseTrackBar, Math;

// Variablenrecord, in dem sämtliche Informationen für die Tische gespeichert werden
// sollen. Dieser Typ wird in der Komponenten-Klasse als Array für 3 Komponenten
// aufgerufen und wird dann über die Tischauswahl-Combobox und Index gesteuert.
Type TTischInfo = record
    daktuellePosition, dZielPosition, daktuelleGeschwindigkeit,
    daktuelleBeschleunigung, ddefinierteGeschwindigkeit, ddefinierteBeschleunigung,
    dobereGrenze, duntereGrenze: double;
    iSchrittweitenIndex: integer;
    bBewegtSich, bVerfügbarkeit: boolean;
end;

Type TOnChangeEvent = procedure of Object;
Type TOnTrackBarMouseDownEvent = procedure of Object;
Type TOnTrackBarMouseUpEvent = procedure of Object;

Type TTischsteuerung = class(TWinControl)
  private
    // Komponenten auf der Bedienoberfläche
    FLblContainerCaption,                              // Überschrift Komponente
    FLblTrackBar,                                      // sich bewegendes Label für
                                                       // Tischposition am Trackbar
    // Statuslabels
    FLblStatusCaption, FLblStatusEinsatzbereitschaft,
    FLblStatusEinsatzbereitschaftAnzeige, FLblStatusAktuellePos,
    FLblStatusAktuellePosAnzeige, FLblStatusZielPos, FLblStatusZielPosAnzeige,
    FLblStatusBewegung, FLblStatusBewegungAnzeige, FLblStatusAktuelleGeschwindigkeit,
    FLblStatusAktuelleGeschwindigkeitAnzeige,FLblStatusAktuelleBeschleunigung,
    FLblStatusAktuelleBeschleunigungAnzeige, FLblStatusDefinierteGeschwindigkeit,
    FLblStatusDefinierteGeschwindigkeitAnzeige, FLblStatusDefinierteBeschleunigung,
    FLblStatusDefinierteBeschleunigungAnzeige, FLblStatusPotenzLabeldefBeschleunigung,
    FLblStatusPotenzLabelaktBeschleunigung,
    FLdlEingabe: TLabel;                               // Label für EingabeEdit

    // Edit das nur Ganze- und Gleitkommazahlen annimmt
    FEdPositionsEingabe,                               // Edit für Positionseingabe
    FEdmanuelleBeschleunigungsEingabe,                 // Edit für manuelle Beschl.-Eingabe
    FEdmanuelleGeschwindigkeitsEingabe: TZahlEdit;     // Edit für manuelle Geschw.-Eingabe

    FTrckBarTischposition: TMouseTrackBar;             // Trackbar das um die OnMouseDown
                                                       // OnMouseUp Ereignisse erweitert
                                                       // wurde

    // Buttons (selbsterklärend)
    FButtonEditEingabe, FButtonMoveLeft, FButtonMoveRight,
    // Buttons für manuelle Geschwindigkeits- und Beschleunigungseingabe
    FButtonmanuelleGeschwEingabe, FButtonmanuelleBeschlEingabe: TButton;

    // Comboboxen Tischauswahl und Schrittweite
    FCombBoxTischauswahl,FComboBoxStepWidth: TComboBox;

    // Image für Bilddarstellung
    FImageSelectionsBild: TImage;

    // Checkbox für Automatisierung der Beschleunigung und Geschwindigkeit
    FCheckBoxAutomatisierung: TCheckBox;

// Variablen

    // benötigte Variabeln für die Komponente
    fdTischposition, fdZielposition, fdUeberschneidung: double; // Double für aktuelle Tischpos
                                                        // des ausgewählten Tisches

// Variablen für Komunikation Komponente <--> Hauptprogramm

    // Das Array für die Tischkomponenten
    ftTischInfo: Array[1..3] of TTischInfo;
    // Variable die speichert, ob die Mouse auf dem Trackbar gedrückt ist oder nicht
    bTrackBarMouseDown: boolean;                        // zu dieser Variable gibt
                                                        // es keinen Getter oder Setter
                                                        // sie wird direkt in der
                                                        // OnMouseDown und OnMouseUp
                                                        // procedure vom Trackbar
                                                        // gesetzt.

// Variablen für Events

    //OnChange-Variable
    FOnChange: TOnChangeEvent;                          // Variable für das OnChange-Ereignis
    FOnTrackBarMouseDown: TOnTrackBarMouseDownEvent;    // Variable für das OnTrackBarMouseDown-
                                                        // Ereignis
    FOnTrackBarMouseUp: TOnTrackBarMouseUpEvent;

// Prozeduren und Funktionen

    // Setterproceduren und Getterfunktionen
    procedure SetContainerCaption(Value: string);       // Setzt eine Überschrift
    procedure SetTischPosition(Value: double);          // Setzt aktuelle Tischpos
    function GetTischPosition: double;                  // Gibt aktuelle Tischpos zurück
    function GetIndex: integer;                         // Ermittelt Index des ausgewählten
                                                        // Tisches
    function GetErweiterung: string;                    // Ermittelt die für den gewählten
                                                        // Tisch benötigte Erweiterung
    function GetAdditionsterm: integer;                 // Ermittelt die für den ausgewählten
                                                        // Tisch nötigen Additionstherm
    procedure SetItemsComboBox(Box: TComboBox);         // Erstellt die für die ComboBox
                                                        // FComboBoxStepWidth nötigen Einträge
    function GetobereGrenze: double;                    // Ermittelt den Wert für die
                                                        // obere Grenze  // Wird durch Verfahr-
                                                        // weg des 2. Verschiebetisches beschränkt
    function GetuntereGrenze: double;                   // Ermittelt den Wert für die
                                                        // untere Grenze
    function GetdefinierteGeschwindigkeit: double;      // Ermittelt die gesetzte Geschwindig-
                                                        // keit für den ausgewählten Tisch
    function GetdefinierteBeschleunigung: double;       // Ermittelt die gesetzte Beschleunigung
                                                        // für den ausgewählten Tisch
    procedure SetaktuelleGeschwindigkeit(dWert: double);// übergibt die aktuelle Geschw. an
                                                        // die Komponente
    procedure SetaktuelleBeschleunigung(dWert: double); // übergibt die aktuelle Beschl. an
                                                        // die Komponente
    procedure Setverfügbarkeit(bWert: boolean);         // Verfügbarkeit der Tische setzen
    function GetZielPosition: double;                   // Ermittelt die Zielposition des
                                                        // ausgewählten Tisches
    procedure SetOnChangeEvent;                         // Setzt das OnChangeEvent
    procedure SetOnTrackBarMouseDownEvent;              // Setzt das OnMouseDownEvent, wenn
                                                        // man dies über dem TrackBar setzt
    procedure SetOnTrackBarMouseUpEvent;                // Setzt das OnMouseUpEvent, wenn
                                                        // man dies über dem TrackBar setzt
    procedure SetUeberschneidung(dWert: double);        // Übergibt den im Hauptprogramm eingestellten
                                                        // Wert für die Überschneidung der Verschiebetische

    // Create-Funktion für alle verwendeten Komponenten
    function CreateLabel(PosX, PosY, Textgroesse: integer; Text: string; Enabled: boolean): TLabel;
    function CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
    function CreateEdit(PosX, PosY, Width: integer; Caption: string; Visible: boolean): TZahlEdit;
    function CreateButton(PosX, PosY, Width, Height: integer; Caption: string; Visible: boolean): TButton;
    function CreateComboBox(PosX, PosY, Width: integer): TComboBox;
    function CreateImage(PosX, PosY, Width, Height: integer): TImage;
    function CreateCheckBox(PosX, PosY, Width, Height: integer; Caption: string): TCheckbox;

    // Verarbeitungsprozeduren

    // Funktion zur Anpassung des Potenzlabels (Position)
    function LabelPosition_anpassen(ReferenzLabel: TLabel): integer;
    // Prozedur, welche bei Aktivierung den ausgewählten Tisch anhalten soll
    procedure TrackBarMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
    // Procedur welche das mitbewegen des Positionslabels bewerkstellig
    procedure TrackBarbewegung(Sender: TObject);
    // Prozedur, welche bei Aktivierung das Bewegungssignal aus der Komponente
    // ausgeben soll
    procedure TrackBarMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
    // Prozeduren zur Positionansteuerung
    procedure Position_ansteuern(Sender: TObject);
    procedure MoveLeftStepWidth(Sender: TObject);
    procedure MoveRightStepWidth(Sender: TObject);
    // Prozedur zum leeren des Edits, wenn draufgeklickt wird
    procedure Edit_leeren(Sender: TObject);
    // Prozedur zum Anpassen der Komponenten bei Änderung des ausgewählten Tisches
    procedure Tischaenderung(Sender: TObject);
    procedure DarstellungTischAuswahl(Index: integer);
    procedure Komponentenanpassung(Index: integer);
    procedure Komponenten_einstellen(Index: integer);
    procedure Komp_laden(Index: integer);
    // Prozdure zur Änderung des Inhaltes von FComboBoxStepWidth bei Wechsel von
    // Verschiebetisch auf Pi-Tisch
    procedure StepWidthAenderung(Sender: TObject);
    // Procedure, die die Automatisierung der Geschwindigkeit und Beschleunigung
    // automatisch steuern soll.
    procedure AutomatisierungGeschwBeschl(Sender: TObject);
    // Procedure lässt das Label FLblStatusDefinierteBeschleunigungAnzeige verschwinden
    // und das dazugehörige Edit FEdmanuelleBeschleunigungsEingabe erscheinen
    procedure manuelleBeschleunigungsEingabe_aktivieren(Sender: TObject);
    // Procedure lässt das Edit FEdmanuelleBeschleunigungsEingabe verschwinden und
    // das dazugehörige Label FLblStatusDefinierteBeschleunigungAnzeige erscheinen
    procedure manuelleBeschleunigungsEingabe_verlassen(Sender: TObject; var Key: Word;
  Shift: TShiftState);
    // Procedure lässt das Label FLblStatusDefinierteGeschwindigkeitAnzeige verschwinden
    // und das dazugehörige Edit FEdmanuelleGeschwindigkeitsEingabe erscheinen
    procedure manuelleGeschwindigkeitsEingabe_aktivieren(Sender: TObject);
    // Procedure lässt das Edit FEdmanuelleGeschwindigkeitsEingabe verschwinden und
    // das dazugehörige Label FLblStatusDefinierteGeschwindigkeitAnzeige erscheinen
    procedure manuelleGeschwindigkeitsEingabe_verlassen(Sender: TObject; var Key: Word;
  Shift: TShiftState);
    // Prozedur, damit die Schrift einiger Labels vor dem Image und der Paintbox
    // liegt
    procedure Schrift_in_den_Vordergrund_bringen;
    // aktualisiert die Statusanzeige
    procedure Status_laden;
    // Procedure die die Kollisionsprüfung für die beiden Verschiebetische durchführt
//*    procedure Kollisionsprüfung;
    // Prozedur zum Erzeugen einer automatischen Geschwindigkeit, Anpassen der
    // Geschwindigkeit an Abstand zur Zielposition und anderen Objekten
    function automatisches_Setzen_Geschwindigkeit(Index: integer): double;
    // Prozedur zum Setzen der Beschleunigung. Da eine schnelle Reaktionsfähigkeit
    // gewollt ist, wird der Wert bei der Automatik immer auf den MaxWert gesetzt
    function automatisches_Setzen_Beschleunigung: double;
    // Prozedur zum Umrechnen der Microsteps in mm.
    function Umrechnung_MicroSteps_in_mm(Wert_in_MicroSteps: double): double;
    // Prozedur um die manuelle Eingabe von Geschwindigkeit und Beschleunigung zu
    // starten und zu akzeptieren.
    procedure Geschw_Beschl_eingeben_und_akzeptieren(Sender: TObject);
    // Bereinigungsprozedur für manuelle Eingabe von Geschw. und Beschleunigung
    //procedure Geschw_Beschl_Eingabe_verlassen(Sender: TObject);
  protected
    // Prozedur initialisiert sämtliche Komponenten
    procedure createWnd; override;

  published
    // OnChange-Event wird ausgelöst, wenn der Zielwert des gewählten Tisches verändert wird
    property OnChange: TOnChangeEvent read FOnChange write FOnChange;
    // Bei der Komponente sind einige Ereignisse wichtig, damit das Hauptprogramm mitbekommt,
    // wenn bestimmte Änderungen an der Komponente vorgenommen werden. So wird der aktuelle
    // Verschiebetisch z.B. gestoppt, wenn man ein MouseDown-Event auf den TrackBar ausführt.
    // Diese Events müssen natürlich nach außen weitergeleitet werden. Dafür sind folgende
    // Events nötig.
    // OnTrackBarMouseDown-Event, um eine Bremsung des ausgewählten Tisches zu realisieren,
    // wenn der die Zielposition geändert wird.
    property OnTrackBarMouseDown: TOnTrackBarMouseDownEvent read FOnTrackBarMouseDown write FOnTrackBarMouseDown;
    // OnTrackBarMouseUp-Event, um Änderungen vorzunehmen die nötig sind, wenn eine Änderung
    // der Zielposition erfolgt ist.
    property OnTrackBarMouseUp: TOnTrackBarMouseUpEvent read FOnTrackBarMouseUp write FOnTrackBarMouseUp;
  public
    // Prozedur initialisiert sämtliche Variablen und Default-Größen
    constructor create(AOwner: TComponent);
    // Eigenschaft die Überschrift zu Ändern
    property ContainerCaption : string write SetContainerCaption;
//* Die aktuelle Position muss für alle 3 Verschiebetische hier übergeben werden,
//* damit das automatische Setzen der Geschwindigkeit auch für den nicht aktivierten
//* Tisch greift. Kollisionsprüfung ist hier von getrennt worden.
    // Eigenschaft zum Lesen und setzen der aktuellen Tischposition
    property Tischposition: double read GetTischPosition write SetTischposition;
    // Eigenschaft ob ausgewählter Tisch gebremst werden muss
    property AenderungZielpositionAktuellerVerschiebetisch: boolean read bTrackBarMouseDown;
    // ObereGrenze des ausgewählten Tisches dies ist die wichtigste Grenzbetrachtung für
    // die Verschiebetische, da hier 2 dynamische Komponenten auf einander treffen.
    property obereGrenze: double read GetobereGrenze;
    // definierte Geschwindigkeit des ausgewählten Tisches
    property definierteGeschwindigkeit: double read GetdefinierteGeschwindigkeit;
    // definierte Beschleunigung des ausgewählten Tisches
    property definierteBeschleunigung: double read GetdefinierteBeschleunigung;
    // aktuelle Geschwindigkeit des gewählten Tisches an die Komponente übergeben
    property aktuelleGeschwindigkeit: double write SetaktuelleGeschwindigkeit;
    // aktuelle Beschleunigung des gewählten Tisches an die Komponente übergeben
    property aktuelleBeschleunigung:double write SetaktuelleBeschleunigung;
    // Verfügbarkeit der Tische setzen
//* Es wird erstmal für alle Tische ein einziger Wert übergeben, der alle Tische
//* freischaltet oder sperrt. Es sollte später versucht werden, dass jeder Tisch
//* für sich freigeschaltet wird.
    property Verfügbarkeit: boolean write SetVerfügbarkeit;
    // Zielpostion des ausgewählten Tisches auslesen
    property Zielposition: double read GetZielPosition;
    // Überschneidung des Tisches, dieser Wert kommt aus der Einstellung des
    // Hauptprogrammes und kann nur von außen gesetzt werden.
    property Ueberschneidung: double write SetUeberschneidung;
end;

{$R Darstellung.RES} 

implementation


{////////////////////////////////////////////////////////////////////////////////////}
{/                                Create-Funktionen                                 /}
{////////////////////////////////////////////////////////////////////////////////////}

constructor TTischsteuerung.create(AOwner: TComponent);
var i: integer;
begin
  inherited create(AOwner);
  Controlstyle := Controlstyle - [csAcceptsControls]; // Der Componente wird nicht erlaubt
                                                      // andere Componenten aufzunehmen,
                                                      // als die, die durch den Programmierer
                                                      // hier einprogrammiert werden.
  Visible := true;
  width := 750;
  height := 700;
  for i := 1 to 3 do
    begin
      if (i in [1,2]) then
      case i of
      1 : begin
            ftTischInfo[i].iSchrittweitenIndex := 4;
            ftTischInfo[i].dObereGrenze := 100;
            ftTischInfo[i].dUntereGrenze := -100;
          end;
      2 : begin
            ftTischInfo[i].iSchrittweitenIndex := 4;
            ftTischInfo[i].dObereGrenze := 100;
            ftTischInfo[i].dUntereGrenze := -2;
          end;
      3 : begin
            ftTischInfo[i].iSchrittweitenIndex := 0;
            ftTischInfo[i].dObereGrenze := 100;
            ftTischInfo[i].dUntereGrenze := 0;
          end;
      end;
      ftTischInfo[i].dZielPosition := 0.0;
      ftTischInfo[i].bBewegtSich := false;
      ftTischInfo[i].bVerfügbarkeit := false;
      ftTischInfo[i].daktuellePosition := ftTischInfo[i].dZielPosition;
      ftTischInfo[i].daktuelleGeschwindigkeit := 0.0;
      ftTischInfo[i].daktuelleBeschleunigung := 0.0;
      ftTischInfo[i].ddefinierteGeschwindigkeit := 2000.0;
      ftTischInfo[i].ddefinierteBeschleunigung := 1000.0;
    end;
  bTrackBarMouseDown := false;                        // Default-Wert setzen
  fdUeberschneidung := 68;                            // Default-Wert setzen
  // CheckBoxinitialisierung
  FCheckBoxAutomatisierung := CreateCheckBox(420, 530, 250, 20, 'Automatisierung Geschw. und Beschl.');
  FCheckBoxAutomatisierung.OnClick := AutomatisierungGeschwBeschl;
end;

function TTischsteuerung.CreateLabel(PosX, PosY, Textgroesse: integer; Text: string; Enabled: boolean): TLabel;
begin
  result := TLabel.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Caption := Text;
  result.Font.Height := Textgroesse;
  result.Enabled := Enabled;
end;

function TTischsteuerung.CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
begin
  result := TMouseTrackbar.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Height := Height;
  result.Width := Width;
  result.Max := 640000;
  result.Position := 320000;
  result.OnMouseDown := TrackBarMouseDown;
  result.OnChange := TrackBarBewegung;
  result.OnMouseUp := TrackBarMouseUp;
end;

function TTischsteuerung.CreateEdit(PosX, PosY, Width: integer; Caption: string; Visible: boolean): TZahlEdit;
begin
  result := TZahlEdit.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Height := 20;
  result.Width := Width;
  result.Text := Caption;
  result.Font.Height := 14;
  result.Visible := Visible;
end;

function TTischsteuerung.CreateButton(PosX, PosY, Width, Height: integer; Caption: string; Visible: boolean): TButton;
begin
  result := TButton.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Caption := Caption;
  result.Height := Height;
  result.Width := Width;
  result.Visible := Visible;
end;

function TTischsteuerung.CreateComboBox(PosX, PosY, Width: integer): TComboBox;
begin
  result := TComboBox.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Height := 20;
  result.Width := Width;
  result.Clear;
end;

function TTischsteuerung.CreateImage(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer): Timage;
begin
  result := TImage.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Width := Width;
  result.Height := Height;
  result.Picture.Bitmap.LoadFromResourceName(HInstance, 'BILD_KAMERA');
  result.Stretch := true;
  result.Visible := true;
  result.BringToFront;
  result.Transparent := true;
  result.Repaint;
end;

function TTischsteuerung.CreateCheckBox(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer; Caption: string): TCheckBox;
begin
  result := TCheckBox.Create(nil);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Width := Width;
  result.Height := Height;
  result.Caption := Caption;
  result.Checked := true;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                           Prozeduren zur Trackbarsteuerung                       /}
{////////////////////////////////////////////////////////////////////////////////////}

// Die OnMouseDown-Prozedure soll bei Aktivierung den ausgewählten Tisch anhalten.
// Es wird als unnötig angesehen, einen Tisch weiter in eine Richtung oder auf eine
// Positionfahren zu lassen, die man in den nächsten Momenten ändern wird.
procedure TTischsteuerung.TrackBarMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  // Hier muss das StopEvent für den ausgewählten Tisch eingegeben werden
  bTrackbarMouseDown := true;
end;

// Die Bewegungsprozedur sorgt dafür, dass das Label welches die Tischposition über
// der Trackbar anzeigt mitgeführt wird.
procedure TTischsteuerung.Trackbarbewegung(Sender: TObject);
var iAdditionsterm: integer;
    sErweiterung: string;
begin
  iAdditionsterm := GetAdditionsterm;
  sErweiterung := GetErweiterung;
  fLblTrackBar.Left :=68 + round((FTrckBarTischposition.Position/640000)*310);
  fLblTrackBar.Caption := Format('%3.3f ' + sErweiterung,[(FTrckBarTischposition.Position/6400)- iAdditionsterm]);
  Status_laden;
end;

// Die OnMouseUp-Prozedure löst bei dem ausgewählten Tisch die neue Bewegung aus. Er
// ändert die Zielposition des ausgewählten Tisches und im Hauptprogramm muss darauf
// dann reagiert werden. Hier bedarf es noch einiger Überarbeitungen und Überlegungen,
//*da folgende Daten sich mit ändern können: obere und untere Grenze.
procedure TTischsteuerung.TrackBarMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
var Index, iAdditionsterm: integer;
begin
  Index := GetIndex;
  iAdditionsterm := GetAdditionsterm;
  ftTischInfo[Index].dZielPosition := (FTrckBarTischposition.Position/6400) - iAdditionsterm;
  bTrackbarMouseDown := false;
  SetOnChangeEvent;
  Status_laden;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                  Funktionen für die Trackbar-Positionssteuerung                  /}
{////////////////////////////////////////////////////////////////////////////////////}

// Leert das Positionseingabe-Edit beim Klicken auf dieses.
procedure TTischsteuerung.Edit_leeren(Sender: TObject);
begin
  fEdPositionsEingabe.Clear;
end;

// Prozedure, die den Edittext überprüft und in einen für den Computer verständlichen
// und für die Funktion kompatiblen Wert konvertiert und dann die Zielposition ändert
// sowie den Trackbar neu setzt.
procedure TTischsteuerung.Position_ansteuern(Sender: TObject);
var Index, iAdditionsterm: integer;
    dWert: double;
begin
  try
    if trystrtofloat(FEdPositionsEingabe.Text, dWert) then
      begin
        dWert := strtofloat(FEdPositionsEingabe.Text);
        Index := GetIndex;
        if ((dWert <= ftTischInfo[Index].dObereGrenze) and (dWert >= ftTischInfo[Index].dUntereGrenze)) then
          begin
            iAdditionsterm := GetAdditionsterm;
            ftTischInfo[Index].dZielPosition := dWert;
            FTrckBarTischposition.Position := round((ftTischInfo[Index].dZielPosition + iAdditionsterm) * 6400);
            FEdPositionsEingabe.Text := 'Wert eingeben';
          end
        else FEdPositionsEingabe.Text := 'Wert eingeben';
      end
  except
    FEdPositionsEingabe.Text := 'Wert eingeben';
  end;
  Status_laden;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                   Funktionen für die Button-Positionssteuerung                   /}
{////////////////////////////////////////////////////////////////////////////////////}

// Mit Klick auf den MoveRightStepWidth-Button führt der Tisch eine Bewegung nach
// rechts aus, die im Rahmen der Genauigkeiten des Tisches, dem Wert der in
// FComboBoxStepWidth-Anzeige entspricht
procedure TTischsteuerung.MoveRightStepWidth(Sender: TObject);
var Index, iAdditionsterm: integer;
    sTemp: string;
begin
  Index := GetIndex;
  sTemp := FComboBoxStepWidth.Text;
  delete(sTemp,Length(sTemp)-2,3);
  if (ftTischInfo[Index].dZielPosition + (strtoint(sTemp))/1000 <= ftTischInfo[Index].dObereGrenze) then
    begin
      iAdditionsterm := GetAdditionsterm;
      ftTischInfo[Index].dZielPosition := ftTischInfo[Index].dZielPosition + (strtoint(sTemp))/1000;
      FTrckBarTischposition.Position := round((ftTischInfo[Index].dZielPosition + iAdditionsterm) * 6400);
    end;
  Status_laden;
end;

// Mit Klick auf den MoveLeftStepWidth-Button führt der Tisch eine Bewegung nach
// links aus, die im Rahmen der Genauigkeiten des Tisches, dem Wert der in
// FComboBoxStepWidth-Anzeige entspricht
procedure TTischsteuerung.MoveLeftStepWidth(Sender: TObject);
var Index, iAdditionsterm: integer;
    sTemp: string;
begin
  Index := GetIndex;
  sTemp := FComboBoxStepWidth.Text;
  delete(sTemp,Length(sTemp)-2,3);
  if (ftTischInfo[Index].dZielPosition - (strtoint(sTemp))/1000 >= ftTischInfo[Index].dUntereGrenze) then
    begin
      iAdditionsterm := GetAdditionsterm;
      ftTischInfo[Index].dZielPosition := ftTischInfo[Index].dZielPosition - (strtoint(sTemp))/1000;
      FTrckBarTischposition.Position := round((ftTischInfo[Index].dZielPosition + iAdditionsterm) * 6400);
    end;
  Status_laden;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                       Setter-Prozeduren und Getter-Funktionen                    /}
{////////////////////////////////////////////////////////////////////////////////////}

// Setzt die Komponentenüberschrift
procedure TTischsteuerung.SetContainerCaption(Value: string);
begin
  FLblContainerCaption.Caption := Value;
end;

// Setzt die aktuelle Tischposition in die Variable fdTischposition. Dies ist nötig, da diese aus dem Verschiebetisch
// ausgelesen wird. Wird für den Tischstatus benötigt
procedure TTischsteuerung.SetTischPosition(Value: Double);
begin
  fdTischposition := Value;
  FTrckBarTischposition.Position := round(fdTischposition*6400);
end;

// Liest die aktuelle Tischposition aus der Variable fdTischposition
function TTischsteuerung.GetTischPosition: double;
begin
  result := fdTischposition;
end;

// Ermittelt den Index für den ausgewählten Tisch anhand der ComboBox FCombBoxTischauswahl
// Hierrüber wird später auch die Identifizierung der Tische im Hauptprogramm laufen
function TTischsteuerung.GetIndex: integer;
begin
  result := (FCombBoxTischauswahl.ItemIndex+1);
end;

// Ermittelt die benötigte Erweiterung (mm oder µm) für die dementsprechenden Anzeigen
function TTischsteuerung.GetErweiterung: string;
var Index: integer;
begin
  Index := GetIndex;
  if Index in [1,2] then result := 'mm'
  else result := 'µm';
end;

// Ermittelt die nötige Verschiebung für den Trackbar. Dies ist nötig, da die Ver-
// schiebetische unterschiedliche Referenzpositionen haben. Die beiden großen
// Verschiebetische haben ihre Referenzposition in der Mitte und der Piezotisch
// am "rechten" Ende. Damit wird eine gleichbehandlung aller Tische und somit
// eine Verringerung der nötigen Prozeduranzahl erreicht.
function TTischsteuerung.GetAdditionsterm: integer;
var Index: integer;
begin
  Index := GetIndex;
  if Index in [1,2] then result := 50
  else result := 0;
end;

function TTischsteuerung.GetuntereGrenze: double;
var Index: integer;
begin
  Index := GetIndex;
  result := ftTischInfo[Index].duntereGrenze;
end;

function TTischsteuerung.GetdefinierteGeschwindigkeit;
var Index: integer;
begin
  Index := GetIndex;
  result := ftTischInfo[Index].ddefinierteGeschwindigkeit;
end;

function TTischsteuerung.GetdefinierteBeschleunigung;
var Index: integer;
begin
  Index := GetIndex;
  result := ftTischInfo[Index].ddefinierteBeschleunigung;
end;

procedure TTischsteuerung.SetaktuelleGeschwindigkeit(dWert: double);
var Index: integer;
begin
  Index := GetIndex;
  ftTischInfo[Index].daktuelleGeschwindigkeit := dWert;
end;

procedure TTischsteuerung.SetaktuelleBeschleunigung(dWert: Double);
var Index: integer;
begin
  Index := GetIndex;
  ftTischInfo[Index].daktuelleBeschleunigung := dWert;
end;

procedure TTischsteuerung.SetVerfügbarkeit(bWert: Boolean);
var Index: integer;
begin
  for Index :=1  to 3 do
    begin
      ftTischInfo[Index].bVerfügbarkeit := bWert;
      if bWert = false then Enabled := false;
    end;
end;

function TTischsteuerung.GetZielPosition;
var Index: integer;
begin
  Index := GetIndex;
  result := ftTischInfo[Index].dZielPosition;
end;

procedure TTischsteuerung.SetOnChangeEvent;
begin
  if assigned(OnChange) then OnChange;
end;

procedure TTischsteuerung.SetOnTrackBarMouseDownEvent;
begin
  if assigned(OnTrackBarMouseDown) then OnTrackBarMouseDown;
end;

procedure TTischsteuerung.SetOnTrackBarMouseUpEvent;
begin
  if assigned(OnTrackBarMouseUp) then OnTrackBarMouseUp;
end;

procedure TTischsteuerung.SetUeberschneidung(dWert: Double);
begin
  fdUeberschneidung := dWert;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/           Anpassen der Komponenten bei Änderung des ausgewählten Tisches         /}
{////////////////////////////////////////////////////////////////////////////////////}

function TTischsteuerung.LabelPosition_anpassen(ReferenzLabel: TLabel): integer;
begin
  result := ReferenzLabel.Left + ReferenzLabel.Width;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/           Anpassen der Komponenten bei Änderung des ausgewählten Tisches         /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischsteuerung.DarstellungTischAuswahl(Index: Integer);
begin
  case Index of
  1: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'BILD_KAMERA'); end;
  2: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'BILD_Referenz'); end;
  3: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'Bild_Piezo'); end;
  end;
end;

procedure TTischsteuerung.Komponenten_einstellen(Index: Integer);
var iAdditionsterm: integer;
begin
  iAdditionsterm := GetAdditionsterm;
  FTrckBarTischposition.Position := round((ftTischInfo[Index].dZielPosition +iAdditionsterm) * 6400);
end;

procedure TTischsteuerung.Komp_laden(Index: integer);
begin
  SetItemsComboBox(FComboBoxStepWidth);
  Status_laden;
  Komponenten_einstellen(Index);
end;

procedure TTischsteuerung.Komponentenanpassung(Index: Integer);
begin
  // Bilddarstellung laden
  DarstellungTischauswahl(Index);
  // Position auslesen für angezeigten Tisch
  // Zielposition für angezeigten Tisch
  Komp_laden(Index);
end;

procedure TTischsteuerung.Tischaenderung(Sender: TObject);
begin
  case FCombBoxTischauswahl.ItemIndex of
  0: Komponentenanpassung(1);
  1: Komponentenanpassung(2);
  2: Komponentenanpassung(3);
  end;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/            Automatische Steuerungsfunktion für Geschw. und Beschl.               /}
{////////////////////////////////////////////////////////////////////////////////////}

// Automatisierungsfunktion hat die Aufgabe, wenn sie an ist (Checkbox gecheckt)
// die Beschleunigungen und Geschwindigkeiten aller Tische zu steuern. Dafür wird
// wenn die Automatisierung durchgeführt wird die Geschwindigkeit und Beschleunigung
// auf einen konstant vorgegebenen Wert angepasst. Die Beschleunigung ist dabei
// immer sehr hoch (sorgt für eine schnelle Reaktion) und die Geschwindigkeit wird
// abhängig von der Entfernung zum Ziel beziehungsweise von einer der beiden Grenzen
// (obere und unter) gesetzt.
procedure TTischsteuerung.AutomatisierungGeschwBeschl(Sender: TObject);
var Index: integer;
begin
  if FCheckBoxAutomatisierung.Checked then
    begin
      FEdmanuelleBeschleunigungsEingabe.Visible := false;
      FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
      FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
      FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
      FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
      FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
      FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
      FLblStatusdefinierteBeschleunigung.Enabled := false;
      FLblStatusdefinierteBeschleunigungAnzeige.Enabled := false;
      FLblStatusdefinierteGeschwindigkeit.Enabled := false;
      FLblStatusdefinierteGeschwindigkeitAnzeige.Enabled := false;
      FLblStatusPotenzLabeldefBeschleunigung.Enabled := false;
      FButtonmanuelleGeschwEingabe.Visible := false;
      FButtonmanuelleBeschlEingabe.Visible := false;
      // hier die Funktionen für automatische Geschwindigkeit und Beschleunigung
      // einfügen.
      for Index := 1 to 2 do ftTischInfo[Index].ddefinierteGeschwindigkeit := automatisches_Setzen_Geschwindigkeit(Index);
      for Index := 1 to 2 do ftTischInfo[Index].ddefinierteBeschleunigung := automatisches_Setzen_Beschleunigung;
    end
  else
    begin
      FLblStatusdefinierteBeschleunigung.Enabled := true;
      FLblStatusdefinierteBeschleunigungAnzeige.Enabled := true;
      FLblStatusdefinierteGeschwindigkeit.Enabled := true;
      FLblStatusdefinierteGeschwindigkeitAnzeige.Enabled := true;
      FLblStatusPotenzLabeldefBeschleunigung.Enabled := true;
      FButtonmanuelleGeschwEingabe.Visible := true;
      FButtonmanuelleBeschlEingabe.Visible := true;
    end;
  Status_laden;
end;

function TTischsteuerung.automatisches_Setzen_Geschwindigkeit(Index: integer): double;
begin
  if (abs(ftTischInfo[Index].daktuellePosition - ftTischInfo[Index].dZielPosition) > 5)  then result := 5000;
  if inRange(abs(ftTischInfo[Index].daktuellePosition - ftTischInfo[Index].dZielPosition), 3, 5)  then result := 2500;
  if inRange(abs(ftTischInfo[Index].daktuellePosition - ftTischInfo[Index].dZielPosition), 1, 3)  then result := 1000;
  if (abs(ftTischInfo[Index].daktuellePosition - ftTischInfo[Index].dZielPosition) < 1)  then result := 500;
end;

function TTischsteuerung.automatisches_Setzen_Beschleunigung;
begin
  result := 5000;
end;

function TTischsteuerung.Umrechnung_MicroSteps_in_mm(Wert_in_MicroSteps: Double): double;
begin
  result := Wert_in_MicroSteps/6400;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                Anzeigen der Edit-Komponente für manuelle Eingaben                /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischsteuerung.Geschw_Beschl_eingeben_und_akzeptieren(Sender: TObject);
var key: Word;
begin
  if Sender = FButtonmanuelleGeschwEingabe then
    begin
      if FButtonmanuelleGeschwEingabe.Caption = 'eingeben' then manuelleGeschwindigkeitsEingabe_aktivieren(FButtonmanuelleGeschwEingabe)
      else
        begin
          key := 13;
          manuelleGeschwindigkeitsEingabe_verlassen(FButtonmanuelleGeschwEingabe, key, []);
        end;
    end
  else
    begin
      if FButtonmanuelleBeschlEingabe.Caption = 'eingeben' then manuelleBeschleunigungsEingabe_aktivieren(FButtonmanuelleBeschlEingabe)
      else
        begin
          key := 13;
          manuelleBeschleunigungsEingabe_verlassen(FButtonmanuelleBeschlEingabe, key, []);
        end;
    end;
end;

procedure TTischsteuerung.manuelleBeschleunigungsEingabe_aktivieren(Sender: TObject);
var sTemp: string;
    key: Word;
begin
  key := 13;
  manuelleGeschwindigkeitsEingabe_verlassen(FButtonmanuelleGeschwEingabe, key, []);
  FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
  FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
  FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
  FLblStatusDefinierteBeschleunigungAnzeige.Visible := false;
  FLblStatusPotenzLabeldefBeschleunigung.Visible := false;
  FEdmanuelleBeschleunigungsEingabe.BringToFront;
  FEdmanuelleBeschleunigungsEingabe.Visible := true;
  sTemp := FLblStatusDefinierteBeschleunigungAnzeige.Caption;
  delete(sTemp, Length(sTemp)-4,5);
  FEdmanuelleBeschleunigungsEingabe.Text := sTemp;
  FButtonmanuelleBeschlEingabe.Caption := 'akzeptieren';
end;

procedure TTischsteuerung.manuelleBeschleunigungsEingabe_verlassen(Sender: TObject; var Key: Word; Shift: TShiftState);
var Index: integer;
    dWert: double;
begin
  Index := GetIndex;
  if (Key = 13) then
    begin
      FEdmanuelleBeschleunigungsEingabe.Visible := false;
      FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
      FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
      FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
      FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
      if trystrtofloat(FEdmanuelleBeschleunigungsEingabe.Text, dWert) then
        begin
          dWert := strtofloat(FEdmanuelleBeschleunigungsEingabe.Text);
          ftTischInfo[Index].ddefinierteBeschleunigung := dWert*6400;
        end;
      Status_laden;
      FButtonmanuelleBeschlEingabe.Caption := 'eingeben';
    end;
end;

procedure TTischsteuerung.manuelleGeschwindigkeitsEingabe_aktivieren(Sender: TObject);
var sTemp: string;
    key: Word;
begin
  key := 13;
  manuelleBeschleunigungsEingabe_verlassen(FButtonmanuelleBeschlEingabe, key, []);
  FEdmanuelleBeschleunigungsEingabe.Visible := false;
  FLblStatusDefinierteBeschleunigungAnzeige.Visible := true;
  FLblStatusDefinierteBeschleunigungAnzeige.BringToFront;
  FLblStatusPotenzLabeldefBeschleunigung.Visible := true;
  FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
  FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := false;
  FEdmanuelleGeschwindigkeitsEingabe.BringToFront;
  FEdmanuelleGeschwindigkeitsEingabe.Visible := true;
  sTemp := FLblStatusDefinierteGeschwindigkeitAnzeige.Caption;
  delete(sTemp, Length(sTemp)-4,5);
  FEdmanuelleGeschwindigkeitsEingabe.Text := sTemp;
  FButtonmanuelleGeschwEingabe.Caption := 'akzeptieren';
end;

procedure TTischsteuerung.manuelleGeschwindigkeitsEingabe_verlassen(Sender: TObject; var Key: Word; Shift: TShiftState);
var Index: integer;
    dWert: double;
begin
  Index := GetIndex;
  if (Key = 13) then
    begin
      FEdmanuelleGeschwindigkeitsEingabe.Visible := false;
      FLblStatusDefinierteGeschwindigkeitAnzeige.Visible := true;
      FLblStatusDefinierteGeschwindigkeitAnzeige.BringToFront;
      if trystrtofloat(FEdmanuelleGeschwindigkeitsEingabe.Text, dWert) then
        begin
          dWert := strtofloat(FEdmanuelleGeschwindigkeitsEingabe.Text);
          ftTischInfo[Index].ddefinierteGeschwindigkeit := dWert*6400;
        end;
      Status_laden;
      FButtonmanuelleGeschwEingabe.Caption := 'eingeben';
    end;
  
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                 Anpassen der Combobox FComboBoxStepWidth                         /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischsteuerung.StepWidthAenderung(Sender: TObject);
var Index: integer;
begin
  Index := GetIndex;
  ftTischInfo[Index].iSchrittweitenIndex := FComboBoxStepWidth.ItemIndex;
end;

procedure TTischsteuerung.SetItemsComboBox(Box: TComboBox);
var sErweiterung: string;
    Index: integer;
begin
  Box.Clear;
  Index := GetIndex;
  if Index in [1,2] then sErweiterung := 'µm'
  else sErweiterung := 'nm';
  Box.Items.Add('5 '+ sErweiterung);
  Box.Items.Add('20 ' + serweiterung);
  Box.Items.Add('100 ' + sErweiterung);
  Box.Items.Add('500 ' + sErweiterung);
  Box.Items.Add('1000 ' + sErweiterung);
  Box.Items.Add('5000 ' + sErweiterung);
  Box.ItemIndex := ftTischInfo[Index].iSchrittweitenIndex;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/                        Prozeduren für die Statusanzeige                          /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischsteuerung.Status_laden;
var Index: integer;
    sErweiterung, sGeschwindigkeitseinheit, sBeschleunigungseinheit: string;
begin
  Index := GetIndex;
  sErweiterung := GetErweiterung;
  sGeschwindigkeitseinheit := 'mm/s';
  sBeschleunigungseinheit := 'mm/s';
  if ftTischInfo[Index].bVerfügbarkeit then FLblStatusEinsatzbereitschaftAnzeige.Caption := 'ja'
  else FLblStatusEinsatzbereitschaftAnzeige.Caption := 'nein';
  FLblStatusAktuellePosAnzeige.Caption := Format('%3.3f '+sErweiterung,[ftTischInfo[Index].daktuellePosition]);
  FLblStatusZielPosAnzeige.Caption := Format('%3.3f '+sErweiterung,[ftTischInfo[Index].dZielPosition]);
  if ftTischInfo[Index].bBewegtSich then FLblStatusBewegungAnzeige.Caption := 'ja'
  else FLblStatusBewegungAnzeige.Caption := 'nein';
  FLdlEingabe.Caption := 'in ' + sErweiterung;
  FLblStatusAktuelleGeschwindigkeitAnzeige.Caption := Format('%3.3f '+sGeschwindigkeitseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[Index].daktuelleGeschwindigkeit)]);
  FLblStatusdefinierteGeschwindigkeitAnzeige.Caption := Format('%3.3f '+sGeschwindigkeitseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[Index].ddefinierteGeschwindigkeit)]);
  FLblStatusAktuelleBeschleunigungAnzeige.Caption := Format('%3.3f '+sBeschleunigungseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[Index].daktuelleBeschleunigung)]);
  FLblStatusdefinierteBeschleunigungAnzeige.Caption := Format('%3.3f '+sBeschleunigungseinheit, [Umrechnung_MicroSteps_in_mm(ftTischInfo[Index].ddefinierteBeschleunigung)]);
  FLblStatusPotenzLabeldefBeschleunigung.Left := LabelPosition_anpassen(FLblStatusdefinierteBeschleunigungAnzeige);
  FLblStatusPotenzLabelaktBeschleunigung.Left := LabelPosition_anpassen(FLblStatusAktuelleBeschleunigungAnzeige);
end;

procedure TTischsteuerung.Schrift_in_den_Vordergrund_bringen;
begin
  FLblTrackBar.BringToFront;
  FLblStatusCaption.BringToFront;
  FLblStatusEinsatzbereitschaft.BringToFront;
  FLblStatusEinsatzbereitschaftAnzeige.BringToFront;
  FLbLStatusAktuellePos.BringToFront;
  FLblStatusAktuellePosAnzeige.BringToFront;
  FLblStatusZielPos.BringToFront;
  FLblStatusZielPosAnzeige.BringToFront;
  FLblStatusBewegung.BringToFront;
  FLblStatusBewegungAnzeige.BringToFront;
  FLblStatusAktuelleGeschwindigkeit.BringToFront;
  FLblStatusAktuelleGeschwindigkeitAnzeige.BringToFront;
  FLblStatusdefinierteGeschwindigkeit.BringToFront;
  FLblStatusdefinierteGeschwindigkeitAnzeige.BringToFront;
  FLblStatusAktuelleBeschleunigung.BringToFront;
  FLblStatusAktuelleBeschleunigungAnzeige.BringToFront;
  FLblStatusPotenzLabeldefBeschleunigung.BringToFront;
  FCheckBoxAutomatisierung.BringToFront;
end;

{////////////////////////////////////////////////////////////////////////////////////}
{/                    Kollisionsüberprüfung für die Verscheibetische                /}
{////////////////////////////////////////////////////////////////////////////////////}

// Vorüberlegung:
// Die Überschneidung der beiden Tische wird der Komponente vom Hauptprogramm übergeben.
// Für den Piezoverschiebetisch ist der Verfahrweg dermaßen klein, dass davon ausgegangen
// werden kann, das dieser vernachlässigbar ist.
// Für die beiden anderen Verschiebetische muss jetzt festgestellt werden in wie weit,
// in Bezug auf die Zielposition des komplimentären Tisches, der Verfahrweg des aktuellen
// Verschiebetisches Eingeschränkt werden muss.

// Obere Grenze ist eigentlich die komplizierteste Rechnung, die es hier gibt. Es muss
// beachtet werden, dass je nach Bewegung der einzelnen Tische der Komplimentärtisch
// Einschränkungen erfährt. Die StandartWerte, die im Konstruktor gesetzt werden, sind
// als Maximalwerte zu sehen. Man sollte jetzt unterscheiden zwischen sich ändernden
// Werten und denen die im Allgemeinen immer gleich sind. Die obere Grenze beider Tische
// ist dabei ein sich ständig ändernder Wert. Die untere Grenze hingegen ist eine eher
// statische Komponente, welche immer ähnliche Werte behält.
function TTischsteuerung.GetobereGrenze: double;
const MaxWert = 100;
var Index, KomplimentIndex: integer;
    dTempWertKomplimentTisch, dTempWertTisch: double;
begin
  Index := GetIndex;
  case Index of
  1 : KomplimentIndex := 2;
  2 : KomplimentIndex := 1;
  3 : KomplimentIndex := 3;
  end;
  if KomplimentIndex in [1..2] then
    begin
      dTempWertKomplimentTisch := MaxWert - ftTischInfo[KomplimentIndex].dZielPosition;
      dTempWertTisch := fdUeberschneidung - dTempWertKomplimentTisch;
      if dTempWertTisch < 0 then result := 100
      else result := MaxWert-dTempWertTisch;
    end
  else result := 100;

end;

// Die untere Grenze muss an sich nicht über eine gesonderte Prozedur oder Funktion gesetzt
// werden, da sie sich relativ statisch verhalten. Es sollte reichen die Werte im
// Konstruktor sinnvoll zu ändern.

{////////////////////////////////////////////////////////////////////////////////////}
{/     Hauptfunktion in dieser Komponente/ Initialisierung sämtlicher Komponenten   /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischsteuerung.CreateWnd;
begin
  inherited createWnd;
  // Bildinitialisierung
  FImageSelectionsBild := CreateImage(17,70,600,496);

  // Labelinitialisierungen
  FLblContainerCaption := CreateLabel(18,10, 21,'Tischsteuerung', true);
  FLblStatusCaption := CreateLabel(430, 350, 18, 'Tischstatus', true);
  FLblStatusEinsatzbereitschaft := CreateLabel(450, 370, 14, 'einsatzbereit:', true);
  FLblStatusEinsatzbereitschaftAnzeige := CreateLabel(555, 370, 14, '', true);
  FLblStatusAktuellePos := CreateLabel(450, 390, 14, 'aktuelle Position:', true);
  FLblStatusAktuellePosAnzeige := CreateLabel(555, 390, 14, '', true);
  FLblStatusZielPos := CreateLabel(450, 410, 14, 'Zielposition:', true);
  FLblStatusZielPosAnzeige := CreateLabel(555, 410, 14, '', true);
  FLblStatusBewegung := CreateLabel(450, 430, 14, 'bewegt sich:', true);
  FLblStatusBewegungAnzeige := CreateLabel(555, 430, 14, '', true);
  FLblStatusAktuelleGeschwindigkeit := CreateLabel(450, 450, 14, 'aktuelle Geschw.:', true);
  FLblStatusAktuelleGeschwindigkeitAnzeige := CreateLabel(555, 450, 14, '', true);
  FLblStatusdefinierteGeschwindigkeit := CreateLabel(450, 470, 14, 'defin. Geschw.:', false);
  FLblStatusdefinierteGeschwindigkeitAnzeige := CreateLabel(555, 470, 14, '', false);
  FLblStatusdefinierteGeschwindigkeitAnzeige.OnClick := manuelleGeschwindigkeitsEingabe_aktivieren;
  FLblStatusAktuelleBeschleunigung := CreateLabel(450, 490, 14, 'aktuelle Beschl.:', true);
  FLblStatusAktuelleBeschleunigungAnzeige := CreateLabel(555,490, 14, '', true);
  FLblStatusdefinierteBeschleunigung := CreateLabel(450, 510, 14, 'defin. Beschl.:', false);
  FLblStatusdefinierteBeschleunigungAnzeige := CreateLabel(555, 510, 14, '', false);
  FLblStatusdefinierteBeschleunigungAnzeige.OnClick := manuelleBeschleunigungsEingabe_aktivieren;
  FLblStatusPotenzLabeldefBeschleunigung := CreateLabel(555, 510, 10, '2', false);
  FLblStatusPotenzLabelaktBeschleunigung := CreateLabel(450, 490, 10, '2', true);
  FLblTrackBar := CreateLabel(68 + round((320000/640000)*310),535,13,'0,000 mm', true);
  FLdlEingabe := CreateLabel(185, 602, 14, 'in mm', true);

  // Trackbarinitialisierungen
  FTrckBarTischposition := CreateTrackBar(68,555,340,20);

  // Editinitialisierung
  FEdPositionsEingabe := CreateEdit(74,600, 90, 'Wert eingeben', true);
  FEdPositionsEingabe.OnEnter := Edit_leeren;
  FEdmanuelleBeschleunigungsEingabe := CreateEdit(552, 507, 60, '', false);
  FEdmanuelleBeschleunigungsEingabe.OnKeyDown := manuelleBeschleunigungsEingabe_verlassen;
  FEdmanuelleGeschwindigkeitsEingabe := CreateEdit(552, 467, 60, '', false);
  FEdmanuelleGeschwindigkeitsEingabe.OnKeyDown := manuelleGeschwindigkeitsEingabe_verlassen;

  // Buttoninitialisierung
  FButtonEditEingabe := CreateButton(230,595, 120, 30,'Position ansteuern', true);
  FButtonEditEingabe.OnClick := Position_ansteuern;
  FButtonMoveLeft := CreateButton(158, 500, 30, 30, '<', true);
  FButtonMoveLeft.OnClick := MoveLeftStepWidth;
  FButtonMoveRight := CreateButton(298, 500, 30, 30, '>', true);
  FButtonMoveRight.OnClick := MoveRightStepWidth;
  FButtonmanuelleGeschwEingabe := CreateButton(650, 470, 80, 20, 'eingeben', false);
  FButtonmanuelleGeschwEingabe.OnClick := Geschw_Beschl_eingeben_und_akzeptieren;
  FButtonmanuelleBeschlEingabe := CreateButton(650, 510, 80, 20, 'eingeben', false);
  FButtonmanuelleBeschlEingabe.OnClick := Geschw_Beschl_eingeben_und_akzeptieren;


  // Comboboxinitialisierung
  FCombBoxTischauswahl := CreateComboBox(17,35, 200);
  FCombBoxTischauswahl.Items.Add('Verschiebetisch Kamera/ Spleißgerät');
  FCombBoxTischauswahl.Items.Add('Verschiebetisch Referenzfaser');
  FCombBoxTischauswahl.Items.Add('Piezoverschiebetisch');
  FCombBoxTischauswahl.ItemIndex := 0;
  FCombBoxTischauswahl.OnChange := Tischaenderung;
  FComboBoxStepWidth := CreateComboBox(210,505,70);
  SetItemsComboBox(FComboBoxStepWidth);
  FComboBoxStepWidth.OnChange := StepWidthAenderung;

  // Nachbearbeitung, damit die richtigen Werte angezeigt und sichtbar sind
  Schrift_in_den_Vordergrund_bringen;
  Status_laden;
end;

end.

Vielen Dank
BAMatze

[mkinzler]

Es fehlt ads override constructor create(AOwner: TComponent); override;

[BAMatze]

Zitat von mkinzler:

Es fehlt ads override constructor create(AOwner: TComponent); override;

lool der ganze Ärger wegen dem kleinen Wort

Danke für die schnelle Hilfe.

Aber mal eine Frage, ich hab ne andere Komponente, da ist auch kein Override drin und trotzdem funzt es. Gibt es dafür eine logische Erklärung??

[mkinzler]

Dort greifst du vielleicht nicht auf die geerbet Methode der Superklasse zu ( kein inherited)