Tag,

ich würde mir gerne eine etwas komplexere Komponente bauen, die erstmal weniger Funktion als Design hat.

So ganz jungfräulich bin ich da jetzt nicht mehr was Komponenten angeht,
aber da ging´s nie um Optik und Verhalten in der IDE oder im erzeugten Programm.

Gibt es da irgendwie einen komfortablen Weg um eine kleine Änderung (Align, Height usw.) sofort zu sehen?
Momentan macht das keine große Freude mit:
Höhe um 1 ändern -> Erzeugen/Compilieren -> Installieren
-> 2te IDE neu auf -> Projekt auf -> kontrollieren -> und von vorn.

Das kanns nicht sein oder?

Kannst du die Komponente nicht erstmal live im Code erzeugen und erst später als Komponente mit Register und so weiter abhandeln?

Wenn verschiedene Bereiche getestet werden sollen, könnte man ggf. innerhalb der Komponente die Tasten + und - abfangen und z.B. Größenänderungen zur Laufzeit vornehmen.

Bei Deiner o.g. Verfahrensweise wäre vielleicht etwas günstiger, die Komponente (bzw. das Package) und das Projekt in einer Projektgruppe zu haben. Dann kannst Du das Package neu installieren und gleich wieder innerhalb der IDE zum Projekt wechseln.
Evtl. müssen nur Formulare geschlossen werden, die die Komponente verwenden - oder sie werden automatisch geschlossen, das weiß ich heute nicht mehr, wie das war.

Zitat von TiGü:

Kannst du die Komponente nicht erstmal live im Code erzeugen und erst später als Komponente mit Register und so weiter abhandeln?

Nuja, die Komponente soll ein Panel werden, auf dem weitere (definierte) Komponenten liegen die man per Property hinzufügt und konfiguriert.
Da ich da nicht sehr sicher mit bin, würde ich das schon gerne sehen wie es in der IDE aussieht.

Die Anzahl der Kinderkomponenten soll auch ab nem bestimmten Punkt nicht mehr sichtbar sein, sondern dann in einem Menü der Wahl verschwinden (siehe Firefox Bookmarksleiste zb.).
Kann man denn nichts tun, um nur einmal (zu welchem Zeitpunkt auch immer) zu installieren und Änderungen werden nach erneutem Erzeugen wirksam?

Zitat von stahli:

Dann kannst Du das Package neu installieren und gleich wieder innerhalb der IDE zum Projekt wechseln.
Evtl. müssen nur Formulare geschlossen werden, die die Komponente verwenden - oder sie werden automatisch geschlossen, das weiß ich heute nicht mehr, wie das war.

Genau dieses Installieren bringt eben nichts, wenn ich die IDE nicht neu starte, deswegen 2 Stück davon.
Aber ich gehe davon, dass ich das grundlegend falsch angehe

Zitat von Towmuz:

Zitat von TiGü:

Kannst du die Komponente nicht erstmal live im Code erzeugen und erst später als Komponente mit Register und so weiter abhandeln?

Nuja, die Komponente soll ein Panel werden, auf dem weitere (definierte) Komponenten liegen die man per Property hinzufügt und konfiguriert.
Da ich da nicht sehr sicher mit bin, würde ich das schon gerne sehen wie es in der IDE aussieht.

Guck, ich meine einfach als Interposer-Klasse. Du ziehst auf deinen Testprojekt ein Panel und deine Komponente "fängt" das sozusagen ab.
So kannst du was ändern, F9 drücken und schauen ob es so okay ist.
Wenn du fertig bist, kannst du es ja wie gehabt per Register und installieren handhaben.

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ExtCtrls, Vcl.StdCtrls;

type
  TPanel = class(Vcl.ExtCtrls.TPanel)
  private
    FLabel: TLabel;
  protected
    procedure Paint; override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

  TForm1 = class(TForm)
    Panel1: TPanel;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TPanel }

constructor TPanel.Create(AOwner: TComponent);
var
  MyRect: TRect;
begin
  inherited;
  FLabel := TLabel.Create(Self);
  FLabel.Parent := Self;
  MyRect := Self.ClientRect;
  FLabel.Left := MyRect.Width div 2;
  FLabel.Top := MyRect.Height div 2;
  FLabel.Width := 50;
  FLabel.Height := 17;
  FLabel.Caption := 'Hello World';
end;

destructor TPanel.Destroy;
begin

  inherited;
end;

procedure TPanel.Paint;
var
  MyRect: TRect;
begin
  inherited;
  MyRect := Self.ClientRect;
  MyRect.Inflate(-10, -10, -10, -10);
  Self.Canvas.Brush.Color := clSilver;
  Self.Canvas.Ellipse(MyRect.Left, MyRect.Top, MyRect.Right, MyRect.Bottom);
end;

Ach so, mal noch eine Ergänzung:

Die Neu-Installation einer Komponente ist eigentlich nur notwendig, um die Änderungen direkt in der IDE zu sehen.
Werte, die bereits in der DFM stehen (wie z.B. die Positionswerte, Visible, Name ect.) bleiben aber natürlich unverändert (also z.B. eine neue Standardgröße wird so nicht angepasst).
Wenn man aber "den Inhalt" einer Komponente ändert, würde man dies in der IDE erst nach einer Neuinstallation der Komponente sehen.

Zur Projekt-Laufzeit würde man die Änderung aber schon sehen, wenn die Komponente neu compiliert wurde (z.B. weil das Komponenten-Package in der gleichen Projektgruppe steht).

Also kann man ggf. zur Laufzeit schon die Änderung sehen und in der IDE noch nicht.

Zitat von TiGü:

Guck, ich meine einfach als Interposer-Klasse.

Danke, so mache ich das gerade (schrubst du ja oben schon) und funktioniert gut soweit. Ich meinte mit meinem ganzen IDE-Gerede allerdings wirklich die IDE (nicht F9 )...
... also die Komponente im Designer (ja, so klingt das verständlicher glaub ich) ...

Da wollte ich über den Objektinspektor (oder eben Rechtsklick auf Komponente) dann weitere Komponenten (auch nur eigene) hinzufügen und im Designer auch sichtbar machen.
Ähnlich Columns von irgendner Liste. Und da das Ding dann per Autosize alles auch gleich skalieren soll, bzw. die Komponenten in den Komponenten in den Komponenten skalieren / ändern / ausblenden.

So wie das Menü im neusten Office zb. (auch wenn das wahrscheinlich mit PageControl beginnt und nicht Panel).

Zitat von stahli:

Ach so, mal noch eine Ergänzung:
Die Neu-Installation einer Komponente ist eigentlich nur notwendig, um die Änderungen direkt in der IDE zu sehen.

Ich probier das nochmal innerhalb einer RADStudio-Umgebung obs das gewünschte Ergebnis bringt.

Vieleicht war es auch einfach zuviel Kaffee heute oder ich muss mal in die Tastaturlogopädiesprechstunde

Ganz früher habe ich auch mal Komponenten gemacht.
Brauchst du wirklich eine eigene Komponente? Tuts nicht auch ein Frame? Seit es die gibt nehme ich nur noch die.
Komponenten würde ich nur noch machen wenn es für andere ist.

Zitat von freimatz:

Ganz früher habe ich auch mal Komponenten gemacht.
Brauchst du wirklich eine eigene Komponente? Tuts nicht auch ein Frame? Seit es die gibt nehme ich nur noch die.
Komponenten würde ich nur noch machen wenn es für andere ist.

Im Prinzip möchte ich ein frei skalierbares Ribbon (vom Minimum, sagen wir mal 300px, bis irgendwas) was nicht nach WinXP oder Vista aussieht (siehe GetIt).
So wie die Office2016 Produkte daherkommen z.B., 2-3 farbig; hochauflösende saubere Icons; flüssiges Verkleinern und -größern; wenn Ansicht kleiner wird, dann tausche ListView im IconModus gegen Comboboxdropdown; kürze Texte von Buttons usw ... ich sehe in der geschilderten Routine zwar mittelmäßig großen Aufwand (nur Windows und VCL), aber keine weitere Lücke in der Wissenshaltung oder -beschaffung für die Umsetzung, die Wissenslücke sehe ich eher in der komfortablen Bedienung der IDE.

Mit Frames kann ich nu allerdings gar nix anfangen, da les ich grad mal drüber, vom Namen her klingt das aber wie etwas individuelles pro Anwendung und genau das Gegenteil wollt ich eigtl.

Ein Frame kann man einmal machen und in beliebig vielen Programmen nutzen, auch mehrere von gleichen Typ auf einem Formular ..., kann eigentlich ähnlich 'nem TPanel genutzt werden.

Ein Frame ist nichts weiter als ein Container für diverse visuelle Komponenten. Ereigbnisroutinen zu den Komponenten auf dem Frame kann man im Frame machen, Größenänderungen ... ebenso.

Größenänderungen der draufliegenden Komponenten macht man im Resize des Frames, da kann man dann auch abfragen, ob die Breite einen bestimmten Wert unterschreitet und dann eine "große" Komponente gegen eine "kleine" austauschen ...