Neue Komponente entwickeln

[josef-b]

Heute ist der Tag :)

Ich möchte erstmals eine neue Komponente entwickeln..

bis jetzt habe ich einige neue Properties hinzugefügt.

(Abgeleitet von TShape)

Delphi-Quellcode:

 private
    FKK_Rechts : boolean;
    FKK_Links : boolean;
    FRM_KK_Rechts : boolean;
    FRM_KK_Links : boolean;
    FQuittierung : boolean;
    FFreigabe : boolean;
    FStoerung : boolean;
    FRechts: boolean;


    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
  public
    { Public-Deklarationen }

  published
    { Published-Deklarationen }
    property KK_Rechts: boolean read FKK_Rechts write FKK_Rechts;
    property KK_Links: boolean read FKK_Links write FKK_Links;
    property RM_KK_Rechts: boolean read FRM_KK_Rechts write FRM_KK_Rechts;
    property RM_KK_Links: boolean read FRM_KK_links write FRM_KK_Rechts;
    property Quittierung: boolean read FQuittierung write FQuittierung;
    property Freigabe: boolean read FFreigabe write FFreigabe;
    property Stoerung: boolean read FStoerung write FStoerung;
    property Rechts: boolean read FRechts write FRechts;

  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('SPS-Visualisierung', [TKlappkasten]);
end;

ich möchte jetzt, dass meine neue Eigenschaften im Objektinspektor unter einer gemeinsamen Kategorie,
nennt man das so ? stehen...

die Kategorie soll heissen "SPS"

also dann im Objektinspektor

SPS.KK_Rechts,
SPS.KK_Links,
usw...

so ähnlich halt wie

Pen.Color,
Pen.Width,
usw.

Danke schon mal im Voraus, ich habe da bestimmt demnächst noch vieeeele Fragen :thumb:

[DeddyH]

Mach doch eine Menge draus.

Delphi-Quellcode:

type
  TSPS = set of (<Deine Werte>);

Was jetzt die einzelnen Booleans definieren ergibt sich dann dadurch, ob sie im Set enthalten sind.

[himitsu]

Jupp, der Enum wird einfacher sein.
Dafür gibt es einen Standard-PropertyEditor, der das wie einzelne Booleans (Checkboxen) im OI darstellt.

Und bei Kategorie dachte ich erst an Kategorie. :roll:
Objektinspektor > Kontextmenü > Anordnen > Nach Kategorie
OpenToolsAPI: RegisterPropertyInCategory RegisterPropertiesInCategory

Pen ist eine Klasse, also eine Unterkomponente in deiner Hauptklasse.
SetSubComponent

[Luckie]

Gibt es mehr Infos zu deine Komponente? Was soll sie machen? Usw.

[josef-b]

Danke erstmal für Eure Antworten.

Es geht darum, eine Visualisierung für eine Anlagensteuerung zu entwickeln.

Dazu habe ich mir überlegt, ich baue mir für die einzelnen Bestandteile, von jeder Art
gibt es auch mehrere einzelne visuelle Komponenten...

z.B.

Silo, Förderband, Siebmaschine, Elevator usw...

so ein Bildchen habe ich mir mal auf einer Form gebastelt...(Anhang)


Dieses grafische/technische Element soll dann ein paar Eigenschaften haben, wie
z.B. LeerMeldung, Vollmeldung (Die LEDS in dem Bildchen z.B. sollen dann verschiedene
Farben zur Laufzeit erhalten.

Ich möchte auch gerne die Größe des gesamten Bildchens zur Entwurfszeit verändern können,
z.B. ungefähr an die masstabsgetreue Länge eines Förderbandes anpassen, oder die Höhe eines
Elevators..

so ein Bildchen habe ich mir mal auf einer Form gebastelt...

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var edit1 : tedit;
Silo: tshape;
VollMelder: tshape;
LeerMelder: tshape;
begin
Silo := tshape.create(self);
with silo do
  begin
  Parent := form1;
  width := 90;
  height := 200;
  brush.color := clmoneygreen;
  shape := strectangle;
  visible := true;
  end;

VollMelder := tshape.create(self);
with Vollmelder do
  begin
  Parent := form1;
  width := 20;
  height := 20;
  top := 20;
  left := 35;
  brush.color := clred;
  shape := stCircle;
  visible := true;
  end;

LeerMelder := tshape.create(self);
with LeerMelder do
  begin
  Parent := form1;
  width := 20;
  height := 20;
  top := 160;
  left := 35;
  brush.color := clyellow;
  shape := stCircle;
  visible := true;
  end;


with form1.canvas do
  begin
  moveto (0,200);
  lineto (45,270);
  lineto (90,200);
  lineto (0,200);
  brush.color := clmoneygreen;
  floodfill(50,210,clblack,fsborder);
  end;

end;

Kann ich das so ähnlich auf eine Komponente übertragen, so dass ich dann das ganze Bildchen
auf der Form habe, wenn ich die Komponente neu aus der Tool-Palette auf die Form schiebe?

Kann ich als Grundlage für die Vererbung ein Panel nehmen und dann die einzelnen Elemente auf
das Panel packen? Oder muss ich das bei der Komponentenentwicklung komplett mit Canvas einzeln
zeichnen? Dann auf eine Paintbox?

Wovon leite ich das ab? TPanel, TPaintbox, Nehme ich dann TPanel oder TPaintbox als Container?

Einfach gesagt, ich bräuchte mal ne grobe Anleitung wie man sowas am besten macht, ich sehe glaub
ich vor lauter Bäumen den Wald nicht mehr:?:

[nahpets]

Als Container würd' ich ein TFrame nehmen.

Da kann man andere Komponenten nach Lust und Laune drauf plazieren und schon die Grundlogik drin implementieren.

Für jedes separate "Teil", das Du dann auf Deinem Form brauchst, nimmst Du ein Frame und kannst dann die einzelnen Komponenten darauf entsprechend ansprechen.

Zuerst machst Du Dir am Sinnvollsten für Silo, Förderband, Siebmaschine, Elevator usw ... jeweils ein Frame.

Davon kannst Du dann beliebig viele und beliebige Kombinationen auf dem Formular / den Formularen anordenen.

[josef-b]

Also ich hatte es mir so vorgestellt, dass Silo, Elevator, Förderband jeweils einzelne Komponenten mit Eigenschaften und Methoden werden.

Also TElevator, TSilo, FFoerderband, sollen also jeweils visuelle Komponenten in der Tool-Palette werden...wie man das dann compiliert und installiert, weiß ich.

Und die visuelle Komponente TSilo soll also auch zur Entwurfszeit so aussehen, wie auf dem Bild-Anhang..

[stahli]

Eine wichtige Frage: Kommst Du immer mit rechteckigen, nicht transparenten Controls aus?

Dann würde ich einfach von Panels ableiten und deren Paint überschreiben.
Dann kannst Du Deine Controls beliebig zeichnen und ja nach Status des Datenbestandes z.B. LED-Farben steuern.

Du könntest einem sichtbaren TvSilo als Property ein Datenobjekt TdSilo zuweisen, dessen Daten sich das Control dann bedienen kann.
Ist kein TdSilo zugewiesen, zeichnet sich das Control einfach nur grau.

Man könnte das Ganze auch noch weiter treiben.
Du könntest ein TdBaustelle haben, die z.B. eine Liste von TdSilos und anderen Objekten beinhaltet.
Eine TvBaustelle (großes Panel im Formular) könnte die TdBaustelle benutzen und einfach alle dort vorhandenen Silos und anderen Objekte zeichnen bzw. für jedes Datenobjekt ein passendes visuelles Objekt erzeugen.
Dazu müssen die Positionen der Objekte allerdings mit in den Datenobjekten gespeichert sein.
Hinzufügungen und Löschungen aus der TdBaustelle.SiloListe müssen ein Neuzeichnen der TvBaustelle veranlassen.


... nur als Überlegung eines möglichen Ansatzes


PS: Welches Delphi hast Du? Schreib das mal mit ins Profil.

[josef-b]

Danke für Eure schnellen Antworten...

ich habe nun mal etwas probiert. Aber ich glaube, ich verstehe es noch nicht mit inherited, constructor und so..

Habe eine Komponente erstellt, compiliert und installiert...beim Compilieren kommt auch kein Fehler.

Nun habe ich gedacht, wenn ich die Komponente auf eine Form ziehe, ändert er mir wenigstens die caption von dem Panel, aber nix ;-) :(

Hier der Code

Delphi-Quellcode:

unit Silo_aus_Panel;

interface

uses
  System.SysUtils, System.Classes, Vcl.Controls, Vcl.ExtCtrls, graphics;

type
  TSilo_aus_Panel = class(TPanel)
  private
    { Private-Deklarationen }
    //Zugriff nur innerhalb der Komponente


  protected
    { Protected-Deklarationen }
   //Deklarationen sichtbar in innerhalb der unit und abgeleiteten Klassen

  public
    { Public-Deklarationen }
    //Steht nur zur Laufzeit zur Verfügung
    //Laufzeit Schnittstelle

  published
    { Published-Deklarationen }
    //kommt in Objektinspektor
    //steht auch im Design-Modus zur Vergügung
    //keine Schreibgeschützten Eigenschaft reinstellen

    constructor create;


  end;

procedure Register;

implementation

constructor Tsilo_aus_Panel.create;
var
Silo: tshape;
VollMelder: tshape;
LeerMelder: tshape;
begin


**** das folgende wird nicht ausgeführt *****

??????


inherited create(self);

caption := 'Neue Caption!';

Silo := tshape.create(self);
with silo do
   begin
   //Parent := form1;       ????
   width := 90;
   height := 200;
   brush.color := clmoneygreen;
   shape := strectangle;
   visible := true;
   end;

end;


procedure Register;
begin
  RegisterComponents('SPS', [TSilo_aus_Panel]);
end;

[nahpets]

Delphi-Quellcode:

constructor Create(AOwner: TComponent); override;
destructor  Destroy; override;

[himitsu]

Zitat:

Delphi-Quellcode:

inherited create(self);

Owner!

Für sich selber kann man nicht der Owner/Besitzer sein.

[DeddyH]

Wieso nicht? Dann gibt man sich selbst frei, wenn man gerade freigegeben wird :mrgreen:

[Medium]

Vergiss das mit dem Ableiten vom Panel am besten schnell wieder. Ich habe exakt genau dieselbe Klamotte für unser Büro vor ein paar Jahren gemacht - also zu 100% genau das was du machen willst - und es kommt zu 100% der Punkt, wo ein unabdingbar rechteckciges undurchsichtiges Etwas einem so RICHTIG in die Suppe spuckt.
Alles was im Wesentlichen einfach nur eine Anzeige sein soll (aber durchaus auch Klick-Ereignisse bietet) wird von TGraphicControl abgeleitet und nichts anderem. Das zeichnet brav auf den Canvas des Parents (üblicherweise ein Formular oder Frame oder Panel) und bringt alles an Basisfunktionalität mit.

Auch von TShapes innerhalb dieser Komponenten würde ich Abstand nehmen. Das sauberste ist es einfach alles von Hand zu malen, und SO viel aufwendiger ist das gar nicht. Mal ein grobes Gerüst:

Delphi-Quellcode:

  TVisuBase = class(TGraphicControl)
  private
  protected
    procedure Paint; override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property Visible;
    property Anchors;
    property Align;
    property Cursor;
    property ShowHint;
    property OnClick;
    property OnContextPopup;
    property OnDblClick;
    property OnMouseDown;
    property OnMouseMove;
    property OnMouseUp;
    property OnMouseWheel;
    property OnMouseWheelDown;
    property OnMouseWheelUp;
    property OnResize;
  end; // Die letzten hier nur um sie im Property-Editor sichtbar zu machen. In TGraphicControl sind diese Member alle nur public, nicht published.

implementation

constructor TVisuBase.Create(AOwner: TComponent);
begin
  inherited;
  // Ab hier Initialisierungen, aber bitte NICHT TShapes und so, und schon gar nicht als lokale Variablen!!
end;

destructor TVisuBase.Destroy;
begin
  // Hier deine Freigaben
  inherited;
end;

procedure TVisuBase.Paint;
begin
  inherited; // <--- Wichtig!!!
  // Hier nun deine Zeichenroutine. Beispiel: Ein Rotes Rechteck mit 5px Abstand zum Rand der Komponente.
  Canvas.Brush.Color := clRed;
  Canvas.Brush.Style := bsSolid;
  Canvas.FillRect(Rect(5, 5, Width-5, Height-5));
end;

Es ist wichtig die überschriebene Methode "Paint" hier zu nehmen, da diese immer aufgerufen wird, wenn Windows der Meinung ist es müsste neugezeichnet werden (Message wmPaint). Man selbst löst dies z.B. durch VisuBase.Repaint; oder VisuBase.Refresh; oder VisuBase.Invalidate; aus, wie mit allen anderen visuellen Komponenten auch. Und mache dich auf jeden Fall damit vertraut alles via "Canvas." zu malen - oder zumindest nichts aus weiteren Komponenten zusammenzusetzen - weil das kann nach hinten raus richtig eklig werden. (Speziell wenn man nachher mit der Zeichenreihenfolge rum machen muss und sich schöne zirkuläre Überlappungen ergeben oder auch Komponenten auf Basis von TWinControl können lustige Sachen machen, etc. pp.)

Ich selbst hatte mir noch eine Zwischenklasse gebaut die von TGraphicControl abgeleitet ist, von der dann alle meine Visu-Klassen ableiten. Das hing aber damit zusammen, das hinter dem ganzen noch ein etwas komplexeres Datenbanksystem steht, mit dem ohnehin alle Komponenten hantieren müssen, so dass es Sinn machte diese Gemeinsamkeit in einen Zwischenschritt zu kapseln. Das aber nur als Anregung, falls es bei dir auch etwas größeres werden soll, nicht nur eine einmalige kleine Maschinensteuerung. (Wir entwickeln damit z.B. ganze Leitsysteme für recht große Anlagen weltweit agierender Konzerne.)

Gedanklich bin ich aber schon längst dabei etwas auf HTML5 zusammenzuspinnen für die Zukunft, aber die Zeit müsste man für sowas erstmal haben :(

[josef-b]

Hallo Medium:

Danke für Deine ausführliche Antwort.

Ich habe schon gemerkt, dass mein Weg vielleicht nicht der ideale ist...und werde es mal auf Deine Art versuchen..

und zwar jetzt :)

Zu dem html5.

Bei mir ist es genau anders. Wir haben hier einige Wago-SPS-Steuerungen. Dazu eine Software von 3S - Codesys. Das
ganze läuft mit Java, was ja von immer mehr browsern nicht mehr unterstützt wird.

Die Steuerungen laufen aber erst 4 Jahre...

Ich habe mich vorher Delphi-maessig mit Datenbanken beschäftigt. Individual-Software für unseren Betriebt mit
Firebird und IBX..Nun habe ich mir in den Kopf gesetzt die SPSen auch mit Delphi anzusteuern. Wir sind damit auch
flexibler, sparen Bauteile bei der SPS ein, z.B. zusätzliche COM-Schnittstellen, die wir direkt übern den PC
anschliessen können, oder über IP-Schnittstellen..

Ausserdem haben wir die Möglichkeit Daten aus der Datenbank mit einfliessen zu lassen...z.B. Waagen-Daten direkt in
die ERP Software zu übernehmen.

Und da will ich dann im hohen Alter eben auch noch lernen, wie man nicht nur Werkzeug-Kästen nutzt, sondern selbst
Komponenten bauen ;-)

[josef-b]

Also das mit der Ableitung von TGraphicControl und händisch zeichnen hat wirklich gut geklappt.

Jetzt habe ich eine kleine visuelle Komponente, oben und unten habe ich eine LED eingebaut,

Voll und Leermelder.

Wie kann ich jetzt zur Laufzeit die Rote Lampe ein und ausschalten und auch die gelbe?

Ich finde bei der neuen Komponente kein Canvas, wo ich das mit floodfill machen kann?

Delphi-Quellcode:

unit SiloZelle;

interface

uses
  System.SysUtils, System.Classes, Vcl.Controls, graphics;

type
  TSiloZelle = class(TGraphicControl)
  private
    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
    procedure Paint; override;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Visible;
    property Anchors;
    property Align;
    property Cursor;
    property ShowHint;
    property OnClick;
    property OnContextPopup;
    property OnDblClick;
    property OnMouseDown;
    property OnMouseMove;
    property OnMouseUp;
    property OnMouseWheel;
    property OnMouseWheelDown;
    property OnMouseWheelUp;
    property OnResize;
  end; // Die letzten hier nur um sie im Property-Editor sichtbar zu machen. In TGraphicControl sind diese Member alle nur public, nicht published.


procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('SPS', [TSiloZelle]);
end;

constructor TSiloZelle.Create(AOwner: TComponent);
begin
  inherited;
  // Ab hier Initialisierungen, aber bitte NICHT TShapes und so, und schon gar nicht als lokale Variablen!!
end;

destructor TSiloZelle.Destroy;
begin
  // Hier deine Freigaben
  inherited;
end;

procedure TSiloZelle.Paint;
begin
  inherited; // <--- Wichtig!!!
  // Hier nun deine Zeichenroutine. Beispiel: Ein Rotes Rechteck mit 5px Abstand zum Rand der Komponente.

  width := 70;
  height := 210;

  with canvas do
    begin

    //Silo-Körper
    pen.Color := clblack;
    Brush.Color := clmoneygreen;
    Brush.Style := bsSolid;
    rectangle(0,0,70,140);

    //Silo-Trichter
    moveto (0,140);
    lineto (35,200);
    lineto (70,140);
    lineto (0,140);
    floodfill(35,160,clblack,fsborder);

    //Vollmelder
     brush.Color := clred;
    ellipse(25,10,50,35);

    //Leermelder
    brush.Color := clyellow;
    ellipse(25,145,50,170)

    end;




end;

[DeddyH]

Auf welchen Canvas greifst Du denn in Deiner Paint-Methode zu, wenn es angeblich keinen gibt?

[josef-b]

Ich habe die Komponente erstellt.

Sie befindet sich auch in der Tool-Palette.

Wenn ich jetzt die Komponente auf ein Formular platziere,
heisst die dann Silozelle1.

Soweit alles gut.

aber was glaub ich nicht geht..

Silozelle1.canvas....irgendwas

Oder muss ich da noch was extra registrieren? Hinzufügen?

[DeddyH]

Was hast Du denn vor? "Von außen" auf Deine Komponente zeichnen?

[mkinzler]

Im Objektinspektor sieht man keinen Canvas. Im Code sollte er aber verfügbar sein.

[DeddyH]

In TGraphicControl ist er aber als protected deklariert, man muss ihn also öffentlich machen.

Delphi-Quellcode:

type
  TSiloZelle = class(TGraphicControl)
  private
    //...
  public
    //...
    property Canvas;
  //...
  end;

[josef-b]

nein im Code ist er auch nicht verfügbar..

Ich möchte einfach nur die Farbe von der aus TGraphicControl abgeleiteten Komponente
zur Laufzeit ändern, in Abhängigkeit von einer Boolschen Variablen.

Genau genommen nicht die ganze Komponente sondern nur zwei "Kreise" darin,
etwas weiter oben sieht man das Teil im Anhang.

So nach dem Motto: if true then farbe = rot, if false then farbe = weiss

[DeddyH]

Das würde ich nicht so machen, sondern im Setter der Property ein Refresh/Repaint/Invalidate aufrufen. Innerhalb der Zeichenroutine wird dann der entsprechende Teil gemäß des Property-Wertes eingefärbt.

[josef-b]

Sorry DeddyH ,

da hatte sich jetzt was überschnitten...

Das hat jetzt geklapt mit dem Canvas.

Habe die property eingefügt.

Danke, aber das mit dem Setter habe ich nicht verstanden.

Kannst du mir das noch etwas genauer erklären, ich bin leider kein gelernter Informatiker, nur Betriebswirt :( ;-)

[Aviator]

Habe gerade mal ausgehend von Detlef's Beispiel im Editor was zusammengeschrieben. Sollte eigentlich funktionieren. Eventuell ist noch der ein oder andere Syntaxfehler drin, aber den bekommst Du dann denke ich aufgelöst. :)

Delphi-Quellcode:

type
  TSiloZelle = class(TGraphicControl)
  private
    FIsEmpty: Boolean;
  protected
    procedure Paint; override;
    procedure SetIsEmpty(Value: Boolean); virtual;
    function GetIsEmpty: Boolean; virtual;
  public
    //...
    property Canvas;
    property IsEmpty: Boolean read GetIsEmpty write SetIsEmpty;
  //...
  end;


procedure TSiloZelle.Paint;
begin
  inherited;

  DoSomePaintStuff();

  if IsEmpty then
    Canvas.Brush.Color := clRed
  else
    Canvas.Brush.Color := clGreen;

  DoSomeOtherPaintStuff();
end;

procedure SetIsEmpty(Value: Boolean);
begin
  FIsEmpty := Value;
  Self.Invalidate;
end;

function GetIsEmpty: Boolean;
begin
  Result := FIsEmpty;
end;

[DeddyH]

Richtig, ich persönlich frage nur immer ab, ob sich der Wert auch tatsächlich geändert hat, damit nicht unnötig neu gezeichnet wird.

Delphi-Quellcode:

type
  TMeineDingensKomponente = class(TGraphicControl)
  private
    FSomeProp: Boolean;
    procedure SetSomeProp(const Value: Boolean);
  //...
  public
    property SomeProp: Boolean read FSomeProp write SetSomeProp;
    //...
  end;

//...

procedure TMeineDingensKomponente.SetSomeProp(const Value: Boolean);
begin
  if FSomeProp <> Value then
    begin
      FSomeProp := Value;
      Invalidate; //In der Paint-Methode dann je nach Wert zeichnen
    end;
end;

[Aviator]

Zitat:

Zitat von DeddyH (Beitrag 1379451)

Richtig, ich persönlich frage nur immer ab, ob sich der Wert auch tatsächlich geändert hat, damit nicht unnötig neu gezeichnet wird.

:thumb: :thumb: :thumb:

Meins war allerdings nur ein Beispiel um zu verdeutlichen was du meintest. Die zusätzlichen Optimierungen habe ich in dem Schritt noch nicht bedacht/beachtet. :wink:

[DeddyH]

Man kann sich auch ein paar OpenSource-Projekte ansehen, z.B. das hier: http://www.delphipraxis.net/71655-bu...nschaften.html oder auch meinen runden Button: http://www.delphipraxis.net/107624-g...ezeichnet.html