Die Zeichenoperation durchführen

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Grafische Komponenten erzeugen - Index

Das wichtigste an einer grafischen Komponente ist die Art und Weise, wie sie sich selbst am Bildschirm zeichnet. Der abstrakte Typ TGraphicControl definiert die Methode Paint, die Sie überschreiben können, um die Komponente nach Ihren eigenen Vorstellungen darzustellen.

Bei der Beispielkomponente muss die Methode Paint verschiedene Aktionen durchführen:

  • Sie muss den vom Benutzer gewählten Stift und Pinsel verwenden.
  • Sie muss die gewählte Figur zeichnen.
  • Sie muss die Koordinaten so zuweisen, dass Rechtecke und Kreise dieselbe Breite und Höhe verwenden.

So überschreiben Sie die Methode Paint:

  1. Fügen Sie Paint der Deklaration der Komponente hinzu.
  2. Schreiben Sie die Paint-Methode im implementation-Abschnitt der Unit.

Fügen Sie für das Shape-Objekt die folgende Deklaration in die Klassendeklaration ein:



 type
   TSampleShape = class(TGraphicControl)
   .
   .
   .
   protected
     procedure Paint; override;
   .
   .
   .
   end;



 class PACKAGE TSampleShape : public TGraphicControl
 {
   .
   .
   .
 protected:
     virtual void __fastcall Paint();
     .
     .
     .
 };



Schreiben Sie dann die Methode in den implementation-Abschnitt der Unit:



 procedure TSampleShape.Paint;
 begin
   with Canvas do
   begin
     Pen := FPen;                                              { Stift der Komponente kopieren }
     Brush := FBrush;                                        { Pinsel der Komponente kopieren }
     case FShape of
       sstRectangle, sstSquare:
         Rectangle(0, 0, Width, Height);                    { Rechtecke und Quadrate zeichnen }
       sstRoundRect, sstRoundSquare:
         RoundRect(0, 0, Width, Height, Width div 4, Height div 4); { Figuren mit abgerundeten Ecken }
       sstCircle, sstEllipse:
         Ellipse(0, 0, Width, Height);                                { Runde Figuren }
     end;
   end;
 end;



 void __fastcall TSampleShape::Paint()
 {
   int X,Y,W,H,S;
   Canvas->Pen = FPen;                                // Stift der Komponente kopieren
   Canvas->Brush = FBrush;                            // Pinsel der Komponente kopieren
   W=Width;                                           // Breite der Komponente verwenden
   H=Height;                                          // Höhe der Komponente verwenden
   X=Y=0;                                             // Kleinsten Wert für Kreise/Quadrate speichernsquares
   if( W<H )
     S=W;
   else
     S=H;
   switch(FShape)
   {
     case sstRectangle:                                // Rechtecke und Quadrate zeichnen
     case sstSquare:
       Canvas->Rectangle(X,Y,X+W,Y+H);
       break;
     case sstRoundRect:                                // Abgerundete Rechtecke und Quadrate zeichnen
     case sstRoundSquare:
       Canvas->RoundRect(X,Y,X+W,Y+H,S/4,S/4);
       break;
     case sstCircle:                                   // Kreise und Ellipsen zeichnen
     case sstEllipse:
       Canvas->Ellipse(X,Y,X+W,Y+H);
       break;
     default:
       break;
   }
 }



Paint wird immer dann aufgerufen, wenn die Komponente ihre Anzeige am Bildschirm aktualisieren muss. Komponenten werden gezeichnet, sobald sie angezeigt werden oder sobald ein darüber angezeigtes Fenster ausgeblendet wird. Sie können ein Neuzeichnen auch explizit durch einen Aufruf von Invalidate veranlassen, wie es beispielsweise die Methode StyleChanged tut.