Performance Problem - viele VCL Komponenten!

[DeddyH]

Wenn es gar nicht anders geht und es unbedingt Einzelkomponenten sein müssen, dann kann es schon etwas bringen, diese nach Möglichkeit von TGraphicControl abzuleiten. Man muss dann halt auf ein Handle verzichten.

[Neumann]

Ich hätte da etwas, ist von mir von der freien Komponente tSimplegraph abgeleitet. Damit kann man einfach zur Laufzeit Pläne mit Komponenten erstellen, die auf Anklicken reagieren. Identifizieren kann man die Objekte in dem Control einfach über den Tag-Wert, den man auch zur Laufzeit setzen kann. Die Pläne lassen sich speichern und laden und das ist absolut schnell.

Die Objekte können in Form, Farbe Hintergrundbilder usw. frei gestaltet werden.

[mschaefer]

Moin, das Create und Notify ist als Zeitfresser schon ausgemacht. Damit sehe ich folgendes:

- Speed-Buttons sind schneller aufgebaut als Normal-Buttons
- Sammlungen aus Buttons können created invisible auf Position 0.0 vorgehalten werden.
- Das Panel mit den Buttons kann während des Aufbaus der Buttons auf invisible stehen.
- Das Panel mit den Buttons könnte bei Align-Top und Höhe 0 auf Align - Client geschaltet werden.
- Ein Image nehmen und bei Mouse-Click die Click-Position abfragen.
- Die Graph-Variante von Neumann klingt spannend.

Grüße in die Runde

[DeddyH]

Zitat von mschaefer:

- Speed-Buttons sind schneller aufgebaut als Normal-Buttons

Zitat:

TSpeedButton = class(TGraphicControl)

Zitat von DeddyH:

Wenn es gar nicht anders geht und es unbedingt Einzelkomponenten sein müssen, dann kann es schon etwas bringen, diese nach Möglichkeit von TGraphicControl abzuleiten.

*Hihi*

[Bummi]

wie wäre es mit sowas, nur als Anregung ....

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;

type
  TPlatzrecord=Record
    x:Integer;
    y:Integer;
    b:Double;
    h:Double;
    farbe:TColor;
    Nr:Integer;
  End;

  TPlatzrecordArray=Array of TPlatzrecord;

  TForm1 = class(TForm)
    Button1: TButton;
    PaintBox1: TPaintBox;
    procedure Button1Click(Sender: TObject);
    procedure PaintBox1Paint(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    FPlatzrecordArray:TPlatzrecordArray;
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation
const
 cColor:Array [0..9] of TColor=(clred,clBlue,cllime,clYellow,clmaroon,clSilver,clGray,clNavy,clBlack,clWhite);

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  x,y:Integer;
begin
    SetLength(FPlatzrecordArray,200);
    for x := 0 to 9 do
    for y := 0 to 19 do
      begin
      FPlatzrecordArray[y*10 + x].x := x;
      FPlatzrecordArray[y*10 + x].y := y;
      FPlatzrecordArray[y*10 + x].nr := y*10 + x;
      FPlatzrecordArray[y*10 + x].h  := 0.8;
      FPlatzrecordArray[y*10 + x].b  := 0.7;
      FPlatzrecordArray[y*10 + x].Farbe  := cColor[y div 2];
      end;
    PaintBox1.Invalidate;
end;

procedure TForm1.PaintBox1Paint(Sender: TObject);
var
  scale:Double;
  x,y:Integer;
  c:TCanvas;
  r:TRect;
begin
  if High(FPlatzrecordArray)<>199 then Exit;

  Scale := paintBox1.Width / 20;
  if paintBox1.height / 20 < Scale  then Scale := paintBox1.height / 20;
  c := PaintBox1.Canvas;
    for x := 0 to 9 do
    for y := 0 to 19 do
      begin
      r.Left := round(FPlatzrecordArray[y*10 + x].x * scale);
      r.Top := round(FPlatzrecordArray[y*10 + x].y * scale);
      r.Right := r.Left + round(FPlatzrecordArray[y*10 + x].b * scale);
      r.Bottom := r.Top + round(FPlatzrecordArray[y*10 + x].h * scale);
      c.Brush.Color := FPlatzrecordArray[y*10 + x].Farbe;
      c.FillRect(r);
      c.Rectangle(r.Left,r.Top,r.Right,r.Bottom);
      c.TextOut(r.Left + (r.Right - r.Left - c.TextWidth(IntToStr(FPlatzrecordArray[y*10 + x].nr))) div 2,
                r.top + (r.bottom - r.top - c.TextHeight(IntToStr(FPlatzrecordArray[y*10 + x].nr))) div 2,
                IntToStr(FPlatzrecordArray[y*10 + x].nr));

      end;



end;

end.

[jaenicke]

Zitat von Bummi:

wie wäre es mit sowas, nur als Anregung ....

Ziemlich genau das (aber mit komplizierterer Berechnung der Positionen) ist es ja was ich in dem Link mache, nur dass es dort bereits ein komplettes Programm ist.

Zitat von jaenicke:

Für den Anwendungszweck wäre es vielleicht sinnvoll die Komponenten selbst zu zeichnen. Eben ohne x separate Komponenten. Damit hatte ich selbst mit hunderten Elementen keinerlei Performanceprobleme.

Wie das geht siehst du hier, wenn auch dort (weil es nur ein Beispiel sein sollte) nicht sonderlich gut optimiert, insbesondere nicht was neue Features aktueller Delphiversionen angeht:
http://www.delphipraxis.net/901617-post.html

[Memo]

Zitat von weisswe:

Hab schon einiges ausprobiert - z.B. LockWindowUpdate usw.
Leider ohne Erfolg. Komponenten werden beim Neuzeichenen (Skalieren sich automatisch bei Window Größenänderung) wieder nur "einzeln" langsam aufgebaut.

Ich hatte das Problem auch schonmal. Mir hat damals ein Tipp in einem anderem Forum geholfen:

Delphi-Quellcode:

try 
  SendMessage(Self.Handle, WM_SETREDRAW, 0, 0); 

  DoWhateverYouWant(); 
finally 
  SendMessage(Self.Handle, WM_SETREDRAW, 1, 0); 
end;