eine Komponente richtig in ein Package packen

[BAMatze]

Hallo und guten Morgen an alle DP´ler,

Also ich hab da mal eine Frage zum erstellen einer Komponenten, denn irgendwie habe ich das Gefühl ich mache da irgendetwas falsch. Als erstes möchte ich erwähnen, dass meine jetzige Komponente 2 weiter Komponenten enthält, die ich früher schonmal erstellt habe.

Ok jetzt zu meinem Vorgehen:
1.) habe meine Komponente gemäß dem Tutorial von Ray Konopka geschrieben (1.Variante mit dynamisch erstellten Einzelkomponenten die als create-Param Self haben) und funzt auch (soweit ich das beurteilen kann). Lasse es derzeit immer in einer extra-Unit in einem Test-Projekt laufen aber nicht als feste Komponente von Delphi sondern ebend als dynamisch erzeugte.
2.) Ich weiß ich muss jetzt ein Package machen. Ich mache dies derzeit wie folgt (hier bin ich mir ebend nicht sehr sicher), ich erstelle ein neues Package und über den Menue-Punkt für neue Komponenten erzeuge ich mir eine neue Komponente die den gleichen Typ hat, wie die die ich vorbereitet habe. Vergebe die richtigen Namen und so weiter und kopiere mir den dementsprechenden Quelltext in diese Komponenten hinein. Dabei achte ich natürlich drauf die Registrierungs-Procedure nicht zu löschen.
3.) Danach kompiliere und installiere ich die Komponente. Dies führt regelmäßig zu folgenden Fehlern, wo ich nicht weiß, wie sie entstehen.

1. Fehler: Es wird die eigentliche Komponente installiert + zusätzlich der 2 von mir schon früher installierten und in der Komponente verwendeten Komponenten (sind ja über uses eingebunden).
2. Fehler: Wenn die Komponenten installiert wurde enthält sie kein Element.
3. Fehler: Die Komponente ist nur in der Instanz verwendbar, in der ich sie installiere. Wenn ich Delphi wieder neu starte, meldet er sinngemäß, dass er probleme hatte diese Komponente zu laden. Die genaue Fehlermeldung reiche ich noch nach, bin gerade wieder dabei die vorläufige Version der Komponente zu erstellen.

Ich hoffe jemand erkennt, wo ich etwas falsch mache und kann mir das sagen. Eigentlich bin ich der Meinung, ich halte mich an die Vorgaben, die ich sowohl bei Ray Konopka, als auch bei dem Tut auf Delphi-Treff gelernt habe.

Vielen Dank
BAMatze

Ps.: Ich verwende folgendes System: CodeGear Delphi 2007 für Win 32 Version 11.0.2902.10471 Professional (ist ja vieleicht wichtig falls Bugs oder Updates bekannt sind)

[BAMatze]

Ok auf oki´s Hinweis versuche ich mein Problem plastischer zu gestalten. Ich zeige hier mal wie meine Unit ausschaut, welche ich für ein Composite Control erstellt habe (sind ein paar mehr Zeile, lasse der übersichtlichkeit halber meine Komentare drin, hilft vieleicht, um zu verstehen, was dort gemacht wird). Danach kommt eine Problembeschreibung noch mal

Delphi-Quellcode:

unit TTischsteuerungskomponente;

interface

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

// 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
  TTischkomponente = 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,
//* Hier sollten noch weiter Anzeigen hinzukommen für reale/ gesetzte Geschwindigkeit
//* sowie Beschleunigung
    FLdlEingabe: TLabel;                               // Label für EingabeEdit

    FEdPositionsEingabe: TZahlEdit;                    // Edit das nur Ganze- und
                                                       // Gleitkommazahlen annimmt

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

    // Buttons (selbsterklärend)
    FButtonEditEingabe, FButtonMoveLeft, FButtonMoveRight: TButton;

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

    // Image für Bilddarstellung
    FImageSelectionsBild: TImage;

    // Paintbox für Pfeildarstellung
    FPaintBoxTischAnzeige: TPaintbox;
    // benötigte Variabeln für die Komponente
    fdTischposition, fdZielposition: double;            // Double für aktuelle Tischposition
                                                        // 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.
//* Es muss eine Variable Enabled hinzugefügt werden, die die Komponente sperrt, wenn
//* ein Problem bei den Tischen auftritt und freigibt, wenn alle Tische verfügbar
//* sind

// 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
    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

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

    // Verarbeitungsprozeduren
    // 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);
    // 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;

  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;
//* Hier muss geprüft werden, ob es nicht mehr Sinn macht die Werte aller 3 Tische zu
//* übergeben. Die Frage ist einfach: Wo wird die Kollisionsprüfung durchgeführt?
//* sinnvoll wäre es die Kollisionsprüfung hier in der Komponente zu halten, da das
//* Hauptprogramm damit übersichtlicher bleibt.
//* Wenn die Kollisionskontrolle in der Komponente ausgeführt wird, reicht das ausgeben
//* der aktuellen Position des ausgewählten Tisches.
    // 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;
//* Hier muss geprüft werden, ob es nicht mehr Sinn macht die Werte aller 3 Tische zu
//* übergeben. Die Frage ist einfach: Wo wird die Kollisionsprüfung durchgeführt?
//* sinnvoll wäre es die Kollisionsprüfung hier in der Komponente zu halten, da das
//* Hauptprogramm damit übersichtlicher bleibt.
//* Wenn die Kollisionsprüfung in der Komponente ausgeführt wir, dann muss die obere
//* Grenze nur ausgelesen werden. Das Setzen muss dannverhindert werden.
    // ObereGrenze des ausgewählten Tisches
    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;
end;


procedure Register;

{$R Darstellung.RES}

implementation

procedure Register;
begin
  RegisterComponents('Tischsteuerungskomponente', [TTischkomponente]);
end;

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

constructor TTischkomponente.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;
  Color := RGB(240,240,250);
  width := 650;
  height := 700;
  for i := 1 to 3 do
    begin
      if (i in [1,2]) then
        begin
          ftTischInfo[i].iSchrittweitenIndex := 4;
          ftTischInfo[i].dObereGrenze := 100;
          ftTischInfo[i].dUntereGrenze := -100;

        end
      else
        begin
          ftTischInfo[i].iSchrittweitenIndex := 0;
          ftTischInfo[i].dObereGrenze := 100;
          ftTischInfo[i].dUntereGrenze := 0;
        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;
//* Umarbeiten der Geschwindigkeit in m/s und m/s^2
//* geprüft muss noch werden, in welcher Variablenform(int oder double) dies an die
//* Maschine gesendet werden darf! Wenn die Eingabe auf m pro ... umgestellt wird
//* ist es trotzdem sinnvoll Double zu haben anstelle von Int um eine bessere Stufung
//* der Geschwindigkeit zu ermöglichen. Die Umrechnung in Int muss dann bei oder
//* nach der Übergabe in Hauptprogramm vorgenommen werden.
      ftTischInfo[i].ddefinierteGeschwindigkeit := 1000.0; // ist noch in Umdrehungen pro sec
      ftTischInfo[i].ddefinierteBeschleunigung := 1000.0; // ist ebenfalls immer noch in Umdrehungen pro sec^2
    end;
  bTrackBarMouseDown := false;                        // Default-Wert setzen
end;

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

procedure TTischkomponente.CreateStatusLabel(PosX: Integer; PosY: Integer; Textgroesse: Integer; Name: string; Text: string);
begin
  {TLabel(Findcomponent(Name)) := CreateLabel(PosX, PosY, Textgroesse, Text);
  FindComponent(Name+'Anzeige') := CreateLabel(PosX + 105, PosY, Textgroesse, ''); }
end;

function TTischkomponente.CreateTrackBar(PosX,PosY, Width, Height:integer): TMouseTrackBar;
begin
  result := TMouseTrackbar.Create(Self);
  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 TTischkomponente.CreateEdit(PosX, PosY: integer; Caption: string): TZahlEdit;
begin
  result := TZahlEdit.Create(Self);
  result.Parent := Self;
  result.Left := PosX;
  result.Top := PosY;
  result.Height := 20;
  result.Width := 100;
  result.Text := Caption;
  result.OnEnter := Edit_leeren;
end;

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

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

function TTischkomponente.CreateImage(PosX: Integer; PosY: Integer; Width: Integer; Height: Integer): Timage;
begin
  result := TImage.Create(Self);
  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;

{////////////////////////////////////////////////////////////////////////////////////}
{/                           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 TTischkomponente.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 TTischkomponente.Trackbarbewegung(Sender: TObject);
var Index, iAdditionsterm: integer;
    sErweiterung: string;
begin
  Index := GetIndex;
  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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.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 TTischkomponente.SetTischPosition(Value: Double);
begin
  fdTischposition := Value;
  FTrckBarTischposition.Position := round(fdTischposition*6400);
end;

// Liest die aktuelle Tischposition aus der Variable fdTischposition
function TTischkomponente.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 TTischkomponente.GetIndex: integer;
begin
  result := (FCombBoxTischauswahl.ItemIndex+1);
end;

// Ermittelt die benötigte Erweiterung (mm oder µm) für die dementsprechenden Anzeigen
function TTischkomponente.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 TTischkomponente.GetAdditionsterm: integer;
var Index: integer;
begin
  Index := GetIndex;
  if Index in [1,2] then result := 50
  else result := 0;
end;

function TTischkomponente.GetobereGrenze: double;
var Index: integer;
begin
  Index := GetIndex;
  result := ftTischInfo[Index].dobereGrenze;
end;

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

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

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

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

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

procedure TTischkomponente.Setverfügbarkeit(bWert: Boolean);
var Index: integer;
begin
  for Index :=1  to 3 do ftTischInfo[Index].bVerfügbarkeit := bWert;
end;

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

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

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

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

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

procedure TTischkomponente.DarstellungTischAuswahl(Index: Integer);
begin
  case Index of
  1: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'BILD1'); end;
  2: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'BILD2'); end;
  3: begin FImageSelectionsBild.Picture.Bitmap.LoadFromResourceName(HInstance, 'Bild3'); end;
  end;
end;

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

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

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

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

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

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

procedure TTischkomponente.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[GetIndex].iSchrittweitenIndex;
end;
{////////////////////////////////////////////////////////////////////////////////////}
{/                        Prozeduren für die Statusanzeige                          /}
{////////////////////////////////////////////////////////////////////////////////////}

procedure TTischkomponente.Status_laden;
var Index, iAdditionsterm: integer;
    sErweiterung, sGeschwindigkeitseinheit, sBeschleunigungseinheit: string;
begin
  Index := GetIndex;
  sErweiterung := GetErweiterung;
  sGeschwindigkeitseinheit := 'U/s';
  sBeschleunigungseinheit := 'U/s^2';
  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, [ftTischInfo[Index].daktuelleGeschwindigkeit]);
  FLblStatusdefinierteGeschwindigkeitAnzeige.Caption := Format('%3.3f '+sGeschwindigkeitseinheit, [ftTischInfo[Index].ddefinierteGeschwindigkeit]);
  FLblStatusAktuelleBeschleunigungAnzeige.Caption := Format('%3.3f '+sBeschleunigungseinheit, [ftTischInfo[Index].daktuelleBeschleunigung]);
  FLblStatusdefinierteBeschleunigungAnzeige.Caption := Format('%3.3f '+sBeschleunigungseinheit, [ftTischInfo[Index].ddefinierteBeschleunigung]);
end;

procedure TTischkomponente.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;
end;

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

procedure TTischkomponente.CreateWnd;
begin
  inherited createWnd;
  // Labelinitialisierungen
  FLblContainerCaption := CreateLabel(18,10, 21,'Tischsteuerung');
  FLblStatusCaption := CreateLabel(430, 450, 18, 'Tischstatus');
  FLblStatusEinsatzbereitschaft := CreateLabel(450, 470, 14, 'einsatzbereit:');
  FLblStatusEinsatzbereitschaftAnzeige := CreateLabel(555, 470, 14, '');
  //CreateStatusLabel(450, 470, 14, 'FLblStatusEinsatzbereitschaft', 'einsatzbereit:');
  FLblStatusAktuellePos := CreateLabel(450, 490, 14, 'aktuelle Position:');
  FLblStatusAktuellePosAnzeige := CreateLabel(555, 490, 14, '');
  FLblStatusZielPos := CreateLabel(450, 510, 14, 'Zielposition:');
  FLblStatusZielPosAnzeige := CreateLabel(555, 510, 14, '');
  FLblStatusBewegung := CreateLabel(450, 530, 14, 'bewegt sich:');
  FLblStatusBewegungAnzeige := CreateLabel(555, 530, 14, '');
  FLblStatusAktuelleGeschwindigkeit := CreateLabel(450, 550, 14, 'aktuelle Geschw.:');
  FLblStatusAktuelleGeschwindigkeitAnzeige := CreateLabel(555, 550, 14, '');
  FLblStatusdefinierteGeschwindigkeit := CreateLabel(450, 570, 14, 'defin. Geschw.:');
  FLblStatusdefinierteGeschwindigkeitAnzeige := CreateLabel(555, 570, 14, '');
  FLblStatusAktuelleBeschleunigung := CreateLabel(450, 590, 14, 'aktuelle Beschl.:');
  FLblStatusAktuelleBeschleunigungAnzeige := CreateLabel(555,590, 14, '');
  FLblStatusdefinierteBeschleunigung := CreateLabel(450, 610, 14, 'defin. Beschl.:');
  FLblStatusdefinierteBeschleunigungAnzeige := CreateLabel(555, 610, 14, '');
  FLblTrackBar := CreateLabel(68 + round((320000/640000)*310),605,13,'0,000 mm');
  FLdlEingabe := CreateLabel(185, 657, 14, 'in mm');

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

  // Editinitialisierung
  FEdPositionsEingabe := CreateEdit(74,655, 'Wert eingeben');

  // Buttoninitialisierung
  FButtonEditEingabe := CreateButton(230,650, 120,'Position ansteuern');
  FButtonEditEingabe.OnClick := Position_ansteuern;
  FButtonMoveLeft := CreateButton(158, 570, 30, '<');
  FButtonMoveLeft.OnClick := MoveLeftStepWidth;
  FButtonMoveRight := CreateButton(298, 570, 30, '>');
  FButtonMoveRight.OnClick := MoveRightStepWidth;

  // 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,575,70);
  SetItemsComboBox(FComboBoxStepWidth);
  FComboBoxStepWidth.OnChange := StepWidthAenderung;

  // Bildinitialisierung
  FImageSelectionsBild := CreateImage(17,70,600,496);

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

end.

Ok nun zur Problemdarstellung: wenn ich die Komponente versuche über das Package in dem es liegt zu installieren, so werden (bei gleichem Vorgehen) 2 unterschiedliche Ergebnisse/ Fehler auftreten.

Bei der ersten Möglichkeit werden die folgenden 3 Komponenten installiert TZahlEdit, TMouseTrackBar und TTischsteuerungskomponente, obwohl ich eigentlich nur die TTischsteuerungskomponente installieren möchte. Wenn dies installiert ist kann ich in dem offenen RadStudio die Komponente TTischsteuerung ohne Probleme verwenden, sie liegt bei den Tools und kann so wie ich das möchte zur Design-Zeit auf die Form gezogen werden. Wenn ich aber RadStudio neu starte ist in dem Package keine Komponente mehr vorhanden.

Bei der zweiten Möglichkeit wird nur die TTischsteuerungskomponente installiert ohne TZahlEdit oder TMousTrackBar. Ich kann wieder die TTischsteuerungskomponente in dem Radstudio in dem ich die Komponente installiert habe in einem neuen Projekt verwenden, wenn ich aber RadStudio neu starte erfolgt die Fehlermeldung, dass die Komponente nicht geladen werden kann und ob ich sie später laden möchte (Antwortmöglichkeiten auf diese Meldung Ja/Nein).

Hoffe die Beschreibung meines Problems ist mir hier besser gelungen und man kann mir sagen, wo ich was falsch mache. Bin derzeit echt ratlos und verwundert, warum bei gleichem Vorgehen 2 mögliche unterschiedliche Fehlerquellen auftreten.

Vielen Dank
BAMatze

[oki]

ok,

das ist schon mal ein Ansatz.

Ohne den Code ganz gelesen zu haben, folgende erste Dinge:

1. Ich nehme mal an, dass die Komponente TZahlEdit in der Unit ZahlEdit steckt (usw.). Rufe dein altes Package auf, in dem die Unit ZahlEdit enthalten ist und lager die Register-Procedure in eine seperate Unit aus (wie ich an anderer Stelle beschrieben habe). Compiliere das alte Package und dort ist wieder alles chico.

Binde das alte Package unter Requires (Benötigt) in deinem neuen Package ein. Solltest du die Unit ZahlEdit in deinem neuen Package unter Containes (Verwendet) haben, dann entferne die da.

Jetzt kannst du dein Package compilieren, ohne das die Kompo ein zweites mal installiert wird. Ich denke, der wichtige Teil ist, dass du die Unit incl. Register in beiden Packages unter Containes eingebunden hast.

2. Wenn du im CreateWnd die Funtionen für das creieren der "eingebetteten Komponenten" aufrufst ist das prinzipiell die richtige Stelle. In den einzelnen Funktionen benutze aber mal nil als Owner und weise self als Parent zu.

Damit sollte schon mal einiges besser laufen.

Gruß oki

[BAMatze]

Ah danke dir schonmal oki, dass du dir die Mühe gemacht hast mir dem anschauen des Codes, sitze hier schon seit geraumer Zeit und versuche einiges, leider sind solche Lösungsansätze für zu finden noch nicht so einfach.
Es wird denke ich jetzt eine Weile dauern, dass ganze Umzusetzen.
Ähm was ich noch nicht so verstanden habe, ist der Teil mit dem Containes und den Requires. Ich werde natürlich gleich mal die SuFu quälen damit aber generell binde ich bisher (warscheinlich auch nur, weil mir Require und Contain noch nicht viel sagt) alles unter uses ein, so wie in meinem Quellcode zu sehen ist. Die einzige Unterscheidung (ich denke mal, dann auch keine sehr gute) die ich vornehme ist eine Einbindung im Interface-Bereich und eventuell wenn 2 Units auch gegenseitig auf einander verweisen sollen dann noch im implementation-Teil.

Könntest vieleicht deswegen nochmal etwas ausführlicher auf den genannten Bereich Require und Contain eingehen?

[oki]

Hi,

ich hab dir mal einen Screenshot in den Anhang gelegt. Dort siehst du eine Projektgruppe in der sich meine beiden Packages befinden. Jeweils in den Packages gibt es die Sektion "Enthält" und die Sektion "Erfordert" (sorry wenn ich im Wortgebrauch etwas schlampig war). In "Enthält" kannst du direkt die Units hinzufügen die in das Package aufgenommen werden sollen (rechte Maustaste). Dort sollten aber dann keine Units rein, die auch von anderen Packages verwendet werden. Dann das entsprechende Package in "Erforderlich" aufnehmen.

Gruß oki

ups Anhang vergessen hiermit nachgeholt.

[BAMatze]

Ah ok jetzt ist das auch mehr verständlich, habe nie wirklich da drauf geachtet, was dort wirklich steht.

So hab jetzt erstmal die eigenen Komponenten (die die bisher auch funktioniert haben) in ein einziges Package gepackt mit aussagekräftigen Namen und diese wieder installiert.

Werde jetzt daran gehen die problembehaftete Komponente wieder an die geänderte Situation anzupassen.

[BAMatze]

Ok hab deine Anweisungen jetzt alle Abgearbeitet. Die doppelte Installierung der Komponenten ZahlEdit und MouseTrackBar ist wunderbar beseitigt, kann ich nur sagen top.

Leider ist auch hier nach Neustart von Delphi, das Package regulär installiert, enthält aber keine Komponente . Die Registrierung ist auch wie du empfohlen hast in einer extra Unit und in Erfordert ist mein Package aufgenommen, das meine beiden Komponenten enthält.

Weißt du woran das liegen könnte, dass die Komponente nach Neustart nicht mehr existiert? findet er eventuell nur eine Datei nicht (dcu oder irgendeine)???
Sollte ich vieleicht nochmal in meinem Ordner, wo die ganzen dcp´s liegen aufräumen, sprich löschen und einfach neu erstellen? da liegt schon ein wenig was drin, nicht, dass er einfach immer eine fehlerhafte findet, wo wirklich nichts drin ist, welche ich ersetzen müsste?

[oki]

Hi,

schau mal im Menü von Delphi unter "Komponenten/Packages installieren..." nach. Dort sollte dein Package aufgeführt sein. Ich kenne dein Problem auch. Das tritt zwar selten auf, ist aber nur damit zu beheben, dass ich dort nicht nur das Häckchen heraus nehme, sondern das Package anwähle und auf Entfernen gehe. Dann neu compilieren und installieren, das wars. Ich darf sehr oft kein neues Projekt laden, dass das frisch installierte Package verwendet. Dann deinstalliert sich das von selbst. Ich muß nach dem Installieren des Packages Delphi einmal schließen. Danach ist alles suppi.

Gruß oki

[oki]

Ähm, ich hab grad gesehen, dass du TurboDelphi in deinem Profil zu stehen hast. Dass du dort in der freien Variante keine Packages installieren kannst ... daran liegt es nicht?

Gruß oki

[BAMatze]

Also das ist vieleicht etwas verwirrend, denn ich verwende privat selber das TurboDelphi (mit dem Stand habe ich mich damals auch angemeldet) und konnte dann aufgrund meines Tätigkeitsfeldes auf Arbeit erreichen, dass hier für meine Arbeit CodeGear Delphi 2007 Professional angeschafft wurde. Die Einschränkungen meiner TurboDelphi-Version für zu Hause sind da natürlich hinderlich, deswegen entwickle ich die Komponenten auch ausschließlich hier auf Arbeit mit der Professional-Version.

Sollte dies sicherlich mal schnell ändern im Profil.

Edit: hab jetzt erst gesehen, dass du schon 2mal geantwortet hast. Das mit dem entfernen und wieder installieren hat jetzt geklappt und scheint die Lösung des Problems zu sein. Ist natürlich irgendwie etwas d..., wenn man den Fehler als Änfänger nicht so kennt und immer gleich aus Verzweiflung alles löscht und nochmal neu probiert.

Komponente existiert.

Danke an oki