Eigene Komponente von TCustomControl > Eigenschaftseditor!

[cherry]

Das ist ja einfach wiedermal genial...

Ich werde dies bei gelegenheit ausprobieren, momentan
bin ich aber immer noch mit dem Button beschäftigt!

Bis irgendwann..

[PeteSky]

Wirklich tolles Beispiel.

Aber wie kann ich in meiner eigenen Komponente den StandardPropertyEditor benutzen?
So das neben meinen Strings im OI dei drei Punkte erscheinen [...] ?

[cherry]

Hey.. schon wieder habe ich ein Problem...
und zwar liegt es diesmal irgendwie an der schrift!

Ich kann den Code zwar Kompilieren, wenn ich die Komponente jedoch auf die Form
ziehe, so gibts einen Fehler. Zugriffsverletzung...

führe ich FEFont.Create; nicht aus funktionierts.

Delphi-Quellcode:

unit EButton;

interface

uses
  SysUtils, Classes, Controls, StdCtrls, Graphics, Messages, Dialogs;

type
  TEnemyleftKind = (Button, ArrowRight, ArrowLeft, Ellipse, PNG);

  TEButton = class(TCustomControl)
  private
    { Private-Deklarationen }
    { Deklarationen der Variablen für die Propertys! }
    FEFont : TFont;
    FEColor : TColor;
    FEColorOver : TColor;
    FEColorDown : TColor;
    FEBrushStyle : TBrushStyle;
    FEBrushStyleOver : TBrushStyle;
    FEBrushStyleDown : TBrushStyle;
    FEPenColor : TColor;
    FEPenColorOver : TColor;
    FEPenColorDown : TColor;
    FEnemyleftKind : TEnemyleftKind;
    FEnemyleftKindOver : TEnemyleftKind;
    FEnemyleftKindDown : TEnemyleftKind;

    EMouseOver : Boolean;

    FEOnMouseDown : TNotifyEvent;
    FEOnMouseUp : TNotifyEvent;
    EMouseDown : Boolean;

    { Deklarationen der Procedures der Propertys
      Die folgenden Procedures verarbeiten erhaltene Propertywerte }

    { Die Zwei folgenden Prozeduren }
    procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER;
    procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
    procedure SetEFont(const Value: TFont);
    procedure SetEColor(const Value: TColor);
    procedure SetEColorOver(const Value: TColor);
    procedure SetEColorDown(const Value: TColor);
    procedure SetEBrushStyle(const Value: TBrushStyle);
    procedure SetEBrushStyleOver(const Value: TBrushStyle);
    procedure SetEBrushStyleDown(const Value: TBrushStyle);
    procedure SetEPenColor(const Value: TColor);
    procedure SetEPenColorOver(const Value: TColor);
    procedure SetEPenColorDown(const Value: TColor);

    procedure SetEOnMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure SetEOnMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
  protected
    { Protected-Deklarationen }
    procedure Paint; override;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }

    { Propertys, Einstellungen die zur entwicklungszeit vorgenommen werden können.
      z.B. bei EFont und EColor [E für Enemyleft^^], werden standardmässige Eigenschafts-
      editoren angezeigt. Sprich Schrift / Farbeditor usw.
      write: geschrieben wird nicht einfach der "Wert" als solches, sonder über eine Prozedur.}

    property EFont: TFont read FEFont write SetEFont;
    property EColor: TColor read FEColor write SetEColor;
    property EColorOver: TColor read FEColorOver write SetEColorOver;
    property EColorDown: TColor read FEColorDown write SetEColorDown;
    property EBrushStyle : TBrushStyle read FEBrushStyle write SetEBrushStyle;
    property EBrushStyleOver : TBrushStyle read FEBrushStyleOver write SetEBrushStyleOver;
    property EBrushStyleDown : TBrushStyle read FEBrushStyleDown write SetEBrushStyleDown;
    property EPenColor : TColor read FEPenColor write SetEPenColor;
    property EPenColorOver : TColor read FEPenColorOver write SetEPenColorOver;
    property EPenColorDown : TColor read FEPenColorDown write SetEPenColorDown;
    property EnemyleftKind: TEnemyleftKind read FEnemyleftKind write FEnemyleftKind;
    property OnMouseDown: TNotifyEvent read FEOnMouseDown write FEOnMouseDown;
    property OnMouseUp: TNotifyEvent read FEOnMouseUp write FEOnMouseUp;

    { Diese Ereignisse wurden geerbt von TCustomControl und können
      deshald so simpel deklariert werden }
      
    property OnClick;
    property OnDblClick;
    property OnDragDrop;
    property OnDragOver;
    property OnEndDrag;
    property OnMouseMove;
  end;

procedure Register;

implementation

procedure Register;
begin
  { Procedure wird bei der Komponenteninstallation verwendet! }
  RegisterComponents('enemyleft', [TEButton]);
end;

constructor TEButton.Create(AOwner: TComponent);
begin
 inherited Create(AOwner);
 { Hier im Konstruktor wird das OnMouseDown/Up-Ereigniss der
   "oberen Klasse (inherited)"  überschrieben }
 inherited OnMouseDown := SetEOnMouseDown;
 inherited OnMouseUp := SetEOnMouseUp;
 Width:=75;
 Height:=25;
 FEFont.Create;
 FEColor:=clWhite;
 FEColorOver:=clAqua;
 FEColorDown:=clBlack;
 FEBrushStyle:=bsSolid;
 FEBrushStyleOver:=bsSolid;
 FEBrushStyleDown:=bsSolid;
 FEPenColor:=clRed;
 FEPenColorOver:=clBlue;
 FEPenColorDown:=clYellow;
 EMouseOver:=false;
 EMouseDown:=false;
end;

destructor TEButton.Destroy;
begin
 FEFont.Free;
 inherited Destroy;
end;

procedure TEButton.Paint;

 { Methode Paint wird überschrieben, die diversen if abfragen sind nötig um
   Den Button korrekt zu Zeichen, trifft das Ereignis MouseDown, oder RollOver
   zu, wird der Button anders gezeichnet als in ComponentState(Entwicklungsumgebung)
   oder wenn kein Ereignis zutrifft. }

begin
 inherited;//Zeichen Procedure des Vorfahren aufrufen.
 if (csDesigning in ComponentState) or (not EMouseOver) then
 begin
  {Zeichung eines Rahmens}
  Canvas.Brush.Color := FEColor;
  Canvas.Brush.Style := FEBrushStyle;
  Canvas.Pen.Color := FEPenColor;
  Canvas.Rectangle(0,0,width,height);//Rechteck zeichnen

  {Namen der Komponente in die Mitte schreiben}
  canvas.Font := FEFont;
  canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

  {Keine weitern Zeichnungen mehr ausführen}
  exit;//Verlässt die Procedure
 end
 else if (EMouseOver) then
 begin
  if (EMouseDown) then
  begin
   Canvas.Brush.Color := FEColorDown;
   Canvas.Brush.Style := FEBrushStyleDown;
   Canvas.Pen.Color := FEPenColorDown;
   Canvas.Rectangle(0,0,width,height);

   canvas.Font := FEFont;
   canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

   exit;
  end
  else
  begin
   Canvas.Brush.Color := FEColorOver;
   Canvas.Brush.Style := FEBrushStyleOver;
   Canvas.Pen.Color := FEPenColorOver;
   Canvas.Rectangle(0,0,width,height);

   canvas.Font := FEFont;
   canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

   exit;
  end;
 end;
end;

{ Proceduren (Selbsterklärens) }

procedure TEButton.CMMouseEnter(var Message: TMessage);
begin
 inherited;
 EMouseOver := true;
 RePaint;
end;

procedure TEButton.CMMouseLeave(var Message: TMessage);
begin
 inherited;
 EMouseOver := false;
 RePaint;
end;

procedure TEButton.SetEFont(const Value: TFont);
begin
 FEFont := Value;
 RePaint;
end;

procedure TEButton.SetEColor(const Value: TColor);
begin
 FEColor := Value;
 RePaint;
end;

procedure TEButton.SetEColorOver(const Value: TColor);
begin
 FEColorOver := Value;
 RePaint;
end;

procedure TEButton.SetEColorDown(const Value: TColor);
begin
 FEColorDown := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyle(const Value: TBrushStyle);
begin
 FEBrushStyle := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyleOver(const Value: TBrushStyle);
begin
 FEBrushStyleOver := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyleDown(const Value: TBrushStyle);
begin
 FEBrushStyleDown := Value;
 RePaint;
end;

procedure TEButton.SetEPenColor(const Value: TColor);
begin
 FEPenColor := Value;
 RePaint;
end;

procedure TEButton.SetEPenColorOver(const Value: TColor);
begin
 FEPenColorOver := Value;
 RePaint;
end;

procedure TEButton.SetEPenColorDown(const Value: TColor);
begin
 FEPenColorDown := Value;
 RePaint;
end;

{ Vor das Ereignis wird die Variable MouseDown, weleche einfluss auf
  auf die Procedure Paint hat auf true gesetzt. /
  Im Konstruktor wird mit "inherited OnMouseDown / UP := Proc" auf die jeweilige
  Procedure hingewiesen, die das Ereignis "steuert" }

procedure TEButton.SetEOnMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
 EMouseDown := true;
 RePaint;
 if Assigned(FEOnMouseDown) then FEOnMouseDown(Sender);
end;

procedure TEButton.SetEOnMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
 EMouseDown := false;
 RePaint;
 if Assigned(FEOnMouseUp) then FEOnMouseUp(Sender);
end;

end.

[Hawkeye219]

Du mußt dem Feld EFont das Ergebnis des Konstruktor-Aufrufs zuweisen:

FEFont := TFont.Create; Gruß Hawkeye

[cherry]

Zu Peinlich man... Vielen Dank..

[MaBuSE]

Zitat von cherry:

Das ist ja einfach wiedermal genial...

Danke

Zitat von PeteSky:

Wirklich tolles Beispiel.

Danke

Zitat von PeteSky:

Aber wie kann ich in meiner eigenen Komponente den StandardPropertyEditor benutzen?
So das neben meinen Strings im OI dei drei Punkte erscheinen [...] ?

Ich verstehe diese Frage nicht ganz.

Die StandardPropertyEditoren werden automatisch verwendet.
Ein Eigenschaft vom Typ TColor bekommt automatisch die [...] um den Farbdialog aufzurufen.
Es gibt auch PropertyEditoren die z.B. an allen eigenschaften vom Typ string hängen und den Namen Caption tragen. Diese sind aber keine StandardPropertyEditoren, sondern einzeln installiert (und vorher programmiert .-)) werden.

Die Drei Punkte bekommt man wenn man in dem Property Editor die GetAttributes Methode implementiert und im ResultSet paDialog zurückgibt. (siehe obiges Beispiel von mir)

Wird der [...] Button gedrückt, so wird die (hoffentlich implementierte) Edit Methode aufgerufen.

Das wars eigentlich.

Hier ein kleines Beispiel, das der Tag Eigenschaft aller Komponenten einen PropertyEditor zuweist. Zusätzlich habe ich noch gezeigt, wie einfach man auch auf mehrere markierte Komponenten reagieren kann.
Also einfach mal instrallieren und ein TLabel, TEdit und TButton aufs Form alle 3 Markieren und dann in der Tag Eigenschaft auf den [...] Button klicken.
In der EditBox erscheint dann der Text:

Zitat:

Folgende Eigenschaften setzen:
Label1.Tag
Edit1.Tag
Button1.Tag

Da auch die Anzeige des Eigenschaftsnamens zur Laufzeit ermittelt wird, kann der PropertyEditor auch anderen Integer Eigenschaften zugewiesen werden.

Delphi-Quellcode:

procedure Register;
begin
  // damit ist der PropertyEditor allen Eingenschaften vom Typ Integer zugewiesen
  RegisterPropertyEditor(TypeInfo(Integer), nil, '', TmyIntegerPropEditor);
end;

Delphi-Quellcode:

///////////////////////////////////////////////////////////////////////////////
// PropertyEditor für Integer
//
// Beispielprogramm zur Komponentenerstellung
//
// Folgende Dinge sind zu sehen:
//   - PropertyEditor für Tag Eigenschaft aller Komponenten
//   - auf mehrere gleichzeitig markierte Komponenten reagieren :-)
//
// Dieser Quelltext liegt auch auf [url]www.delphipraxis.net[/url]
// ( [url]http://www.delphipraxis.net/topic80394_eigene+komponente+von+tcustomcontrol+eigenschaftseditor.html[/url] )
//
///////////////////////////////////////////////////////////////////////////////
// Das Programm ist Freeware und darf beliebig benutzt und erweitert werden.
// Es wäre nett, wenn dann auch der geänderte Quelltext in obige URL-Adresse
// gesendet wird. Dann haben alle was davon.
// Es wäre auch nett wenn mein (unser) Name in den Dateien enthalten bleibt.
// Das Programm wird von Ihnen auf eigenes Risiko eingesetzt. Ich übernehme
// keine Haftung für Schäden die durch das Programm oder die Benutzung des
// Programms entstanden sind bzw. entstehen.
///////////////////////////////////////////////////////////////////////////////
// (C) 2005, MaBuSE, member of DelphiPraxis.net
///////////////////////////////////////////////////////////////////////////////
// ReleaseNotes:
// v1.0 - 18.04.2006 - MaBuSE:      Erste Version war in 5 min programmiert
///////////////////////////////////////////////////////////////////////////////
unit integer_dsgn;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Buttons, DesignIntf, DesignEditors;

type
  TmyIntegerPropEditor = class(TIntegerProperty)
  public
    // hier wird das Formular aufgerufen
    procedure Edit; override;
    // hier wird bestimmt, die das Property im Objektinspektor angezeigt wird
    function GetAttributes: TPropertyAttributes; override;
  end;

procedure Register;

implementation

procedure Register;
begin
  // Der PropertyEditor TmyIntegerPropEditor (4. Parameter)
  // wird für alle Properties:
  // - vom Typ Integer (1. Parameter)
  // - für alle Komponenten (2. Parameter)
  // - mit dem Namen 'Tag'
  // in der Delphi IDE verwendet.
  // Wenn als 2. Parameter nil übergeben wird, dann wird der PropertyEditor von
  // allen Komponenten verwendet.
  // Wenn als 3. Parameter '' übergeben wird, dann wird der PropertyEditor von
  // allen Eigenschaften des Typs Integer verwendet.
  RegisterPropertyEditor(TypeInfo(Integer), nil, 'Tag', TmyIntegerPropEditor);
end;

{ TmyIntegerPropEditor }

procedure TmyIntegerPropEditor.Edit;
var
  i: Integer;
  s: string;
  cc: string;
begin
  inherited;
  // Wenn gleichzeitig mehrere Komponenten markiert sind,
  // alle Komponenten im Prompt Text des Eingabedialogs anzeigen
  if PropCount > 1 then
  begin
    cc := 'Folgende Eigenschaften setzen:'+#13;
  end
  else
  begin
    cc := 'Folgende Eigenschaft setzen: ';
  end;
  
  for i := 0 to PropCount - 1 do
  begin
    // Für jede markierte Komponente
    cc := cc + GetComponent(i).GetNamePath + '.' + GetName + #13;
  end;

  // aktuellen Wert in String s übernehmen
  s := IntToStr(GetOrdValue);

  // den EingabeDialog mit s aufrufen
  if InputQuery('myIntegerPropertyEditor', cc, s) then
  begin
    // s in Integer umwandeln und Eigenschaft setzen
    SetOrdValue(StrToInt(s));
  end;
end;

function TmyIntegerPropEditor.GetAttributes: TPropertyAttributes;
begin
  // [...] Button anzeigen
  Result := inherited GetAttributes + [paDialog];
end;

end.

[cherry]

So, ich gebs auf.. Kann mir jmd helfen?
Das mit Font funzt immer noch nicht und ich werd nicht Schlau dabei... ich habs sicher schon auf 100 verschiedene
arten versucht..
Wenn mann diese Version so wie sie her Steht Compiliert kann man, wenn man den Eigenschaftseditor nicht aufruft
die Schrift teils verändern, eg. Style usw.
Ändert man sie jedoch durch den EigenschaftsEditor wird die Font zwär geändert, gibt aber trotzdem eine Zugriffsverletzung aus!
Ich kriegs nicht hingebogen..
Bitte um hilfe...

Delphi-Quellcode:

unit EButton;

interface

uses
  SysUtils, Classes, Controls, StdCtrls, Graphics, Messages, Dialogs;

type
  TEnemyleftKind = (Button, ArrowRight, ArrowLeft, Ellipse, PNG);

  TEButton = class(TCustomControl)
  private
    { Private-Deklarationen }
    { Deklarationen der Variablen für die Propertys! }
    FEFont : TFont;
   // FEFontOver : TFont;
   // FEFontDown : TFont;
    FEColor : TColor;
    FEColorOver : TColor;
    FEColorDown : TColor;
    FEBrushStyle : TBrushStyle;
    FEBrushStyleOver : TBrushStyle;
    FEBrushStyleDown : TBrushStyle;
    FEPenColor : TColor;
    FEPenColorOver : TColor;
    FEPenColorDown : TColor;
    FEnemyleftKind : TEnemyleftKind;
    FEnemyleftKindOver : TEnemyleftKind;
    FEnemyleftKindDown : TEnemyleftKind;

    EMouseOver : Boolean;

    FEOnMouseDown : TNotifyEvent;
    FEOnMouseUp : TNotifyEvent;
    EMouseDown : Boolean;

    { Deklarationen der Procedures der Propertys
      Die folgenden Procedures verarbeiten erhaltene Propertywerte }

    { Die Zwei folgenden Prozeduren }
    procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER;
    procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
    //procedure SetEFont(const Value: TFont);
    //procedure SetEFontOver(const Value: TFont);
    //procedure SetEFontDown(const Value: TFont);
    procedure SetEColor(const Value: TColor);
    procedure SetEColorOver(const Value: TColor);
    procedure SetEColorDown(const Value: TColor);
    procedure SetEBrushStyle(const Value: TBrushStyle);
    procedure SetEBrushStyleOver(const Value: TBrushStyle);
    procedure SetEBrushStyleDown(const Value: TBrushStyle);
    procedure SetEPenColor(const Value: TColor);
    procedure SetEPenColorOver(const Value: TColor);
    procedure SetEPenColorDown(const Value: TColor);

    procedure SetEOnMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure SetEOnMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
  protected
    { Protected-Deklarationen }
    procedure Paint; override;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }

    { Propertys, Einstellungen die zur entwicklungszeit vorgenommen werden können.
      z.B. bei EFont und EColor [E für Enemyleft^^], werden standardmässige Eigenschafts-
      editoren angezeigt. Sprich Schrift / Farbeditor usw.
      write: geschrieben wird nicht einfach der "Wert" als solches, sonder über eine Prozedur.}

    property EFont: TFont read FEFont write FEFont;
    //property EFontOver: TFont read FEFontOver write SetEFontOver;
    //property EFontDown: TFont read FEFontDown write SetEFontDown;
    property EColor: TColor read FEColor write SetEColor;
    property EColorOver: TColor read FEColorOver write SetEColorOver;
    property EColorDown: TColor read FEColorDown write SetEColorDown;
    property EBrushStyle : TBrushStyle read FEBrushStyle write SetEBrushStyle;
    property EBrushStyleOver : TBrushStyle read FEBrushStyleOver write SetEBrushStyleOver;
    property EBrushStyleDown : TBrushStyle read FEBrushStyleDown write SetEBrushStyleDown;
    property EPenColor : TColor read FEPenColor write SetEPenColor;
    property EPenColorOver : TColor read FEPenColorOver write SetEPenColorOver;
    property EPenColorDown : TColor read FEPenColorDown write SetEPenColorDown;
    property EnemyleftKind: TEnemyleftKind read FEnemyleftKind write FEnemyleftKind;
    property OnMouseDown: TNotifyEvent read FEOnMouseDown write FEOnMouseDown;
    property OnMouseUp: TNotifyEvent read FEOnMouseUp write FEOnMouseUp;

    { Diese Ereignisse wurden geerbt von TCustomControl und können
      deshald so simpel deklariert werden }
      
    property OnClick;
    property OnDblClick;
    property OnDragDrop;
    property OnDragOver;
    property OnEndDrag;
    property OnMouseMove;
  end;

procedure Register;

implementation

procedure Register;
begin
  { Procedure wird bei der Komponenteninstallation verwendet! }
  RegisterComponents('enemyleft', [TEButton]);
end;

constructor TEButton.Create(AOwner: TComponent);
begin
 inherited Create(AOwner);
 { Hier im Konstruktor wird das OnMouseDown/Up-Ereigniss der
   "oberen Klasse (inherited)"  überschrieben }
 //DoubleBuffered := True; {Zeichen Prozesse werden sonst vielleicht in Zwischenstufen angezeigt - Flackern}
 FEFont := TFont.Create;
 inherited OnMouseDown := SetEOnMouseDown;
 inherited OnMouseUp := SetEOnMouseUp;
 //FEFont.Create;
 //FEFontOver := TFont.Create;
 //FEFontDown := TFont.Create;
 FEColor:=clWhite;
 FEColorOver:=clAqua;
 FEColorDown:=clBlack;
 FEBrushStyle:=bsSolid;
 FEBrushStyleOver:=bsDiagCross;
 FEBrushStyleDown:=bsDiagCross;
 FEPenColor:=clRed;
 FEPenColorOver:=clBlue;
 FEPenColorDown:=clYellow;
 EMouseOver:=false;
 EMouseDown:=false;
 Width:=75;
 Height:=25;
end;

destructor TEButton.Destroy;
begin
 FEFont.Free;
 inherited Destroy;
end;

procedure TEButton.Paint;

 { Methode Paint wird überschrieben, die diversen if abfragen sind nötig um
   Den Button korrekt zu Zeichen, trifft das Ereignis MouseDown, oder RollOver
   zu, wird der Button anders gezeichnet als in ComponentState(Entwicklungsumgebung)
   oder wenn kein Ereignis zutrifft. }

begin
 inherited;//Zeichen Procedure des Vorfahren aufrufen.
 if (csDesigning in ComponentState) or (not EMouseOver) then
 begin
  {Zeichung eines Rahmens}
  Canvas.Brush.Color := FEColor;
  Canvas.Brush.Style := FEBrushStyle;
  Canvas.Pen.Color := FEPenColor;
  Canvas.Rectangle(0,0,width,height);//Rechteck zeichnen

  {Namen der Komponente in die Mitte schreiben}
  canvas.Font := FEFont;
  canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

  {Keine weitern Zeichnungen mehr ausführen}
  //exit;//Verlässt die Procedure
 end
 else if (EMouseOver) then
 begin
  if (EMouseDown) then
  begin
   Canvas.Brush.Color := FEColorDown;
   Canvas.Brush.Style := FEBrushStyleDown;
   Canvas.Pen.Color := FEPenColorDown;
   Canvas.Rectangle(0,0,width,height);

   canvas.Font := FEFont;
   canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

   exit;
  end
  else
  begin
   Canvas.Brush.Color := FEColorOver;
   Canvas.Brush.Style := FEBrushStyleOver;
   Canvas.Pen.Color := FEPenColorOver;
   Canvas.Rectangle(0,0,width,height);

   canvas.Font := FEFont;
   canvas.TextOut((width - Canvas.TextWidth(Name)) div 2,(height - Canvas.TextHeight(Name)) div 2,name);

   exit;
  end;
 end;
end;

{ Proceduren (Selbsterklärens) }

procedure TEButton.CMMouseEnter(var Message: TMessage);
begin
 inherited;
 EMouseOver := true;
 RePaint;
end;

procedure TEButton.CMMouseLeave(var Message: TMessage);
begin
 inherited;
 EMouseOver := false;
 RePaint;
end;

{procedure TEButton.SetEFont(const Value: TFont);
begin
 FEFont := Value;
 RePaint;
end;   }

{procedure TEButton.SetEFontOver(const Value: TFont);
begin
 FEFontOver := Value;
 RePaint;
end;

procedure TEButton.SetEFontDown(const Value: TFont);
begin
 FEFontDown := Value;
 RePaint;
end;       }

procedure TEButton.SetEColor(const Value: TColor);
begin
 FEColor := Value;
 RePaint;
end;

procedure TEButton.SetEColorOver(const Value: TColor);
begin
 FEColorOver := Value;
 RePaint;
end;

procedure TEButton.SetEColorDown(const Value: TColor);
begin
 FEColorDown := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyle(const Value: TBrushStyle);
begin
 FEBrushStyle := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyleOver(const Value: TBrushStyle);
begin
 FEBrushStyleOver := Value;
 RePaint;
end;

procedure TEButton.SetEBrushStyleDown(const Value: TBrushStyle);
begin
 FEBrushStyleDown := Value;
 RePaint;
end;

procedure TEButton.SetEPenColor(const Value: TColor);
begin
 FEPenColor := Value;
 RePaint;
end;

procedure TEButton.SetEPenColorOver(const Value: TColor);
begin
 FEPenColorOver := Value;
 RePaint;
end;

procedure TEButton.SetEPenColorDown(const Value: TColor);
begin
 FEPenColorDown := Value;
 RePaint;
end;

{ Vor das Ereignis wird die Variable MouseDown, weleche einfluss auf
  auf die Procedure Paint hat auf true gesetzt. /
  Im Konstruktor wird mit "inherited OnMouseDown / UP := Proc" auf die jeweilige
  Procedure hingewiesen, die das Ereignis "steuert" }

procedure TEButton.SetEOnMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
 EMouseDown := true;
 RePaint;
 if Assigned(FEOnMouseDown) then FEOnMouseDown(Sender);
end;

procedure TEButton.SetEOnMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
 EMouseDown := false;
 RePaint;
 if Assigned(FEOnMouseUp) then FEOnMouseUp(Sender);
end;

end.

[Sidorion]

Zu den Zugriffsverletzungen hab ich erstmal keine Idee, aber Du solltest nicht den Event des Vorgängers überschreiben(OnMouseDown usw.), sondern die Methode MouseDown. Wenn nämlich jemand einen Zeiger auf den Vorgänger hat, dann killt er damir Deine ganze Behandlung mit dem EMouseDown. MouseDown und MouseUp sind Methoden von TControl und rufen dort nur FOnMouse... Wenn Du diese Methoden überschreibst, dann kannst Du Deinen Merker Setzten, Inherited rufen und dann den Repaint ausführen.

[MaBuSE]

Zitat von Sidorion:

...aber Du solltest nicht den Event des Vorgängers überschreiben(OnMouseDown usw.), sondern die Methode MouseDown.

Stimmt.

Zu den Schutzverletzungen:

Das scheint ein Bug im Delphi zu sein oder wir machen was grundlegend falsch.
Bei einer einfachen Komponente (siehe Quelltext) tritt das Problem bei mir auch auf, wenn ich z.B. Arial auswähle.
Ich werde morgen mal schauen woran das liegt. Ach ja ich verwende im Moment Delphi 7. (Ich schau mal was D2006 dazu sagt.)

Delphi-Quellcode:

unit myFontDemoComponent;

interface

uses
  SysUtils, Classes, Graphics;

type
  TmyFontDemoComponent = class(TComponent)
  private
    FFont: TFont;
    procedure SetFont(const Value: TFont);
    { Private-Deklarationen }
  protected
    { Protected-Deklarationen }
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override; 
  published
    { Published-Deklarationen }
    property Font: TFont read FFont write SetFont;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Beispiele', [TmyFontDemoComponent]);
end;

{ TmyFontDemoComponent }

constructor TmyFontDemoComponent.Create(AOwner: TComponent);
begin
  inherited;
  FFont := TFont.Create;
end;

destructor TmyFontDemoComponent.Destroy;
begin
  FFont.Free;
  FFont := nil;
  inherited;
end;

procedure TmyFontDemoComponent.SetFont(const Value: TFont);
begin
  FFont := Value;
end;

end.

[Sidorion]

Ich nehm mal schwer an, das liegt an der Zuweisung:
FFont:=Value Ich geh mal davon aus, dass Value das Fontobjekt des Eigenschafteditors ist. Wenn ja, dann wirds nach dem Aufruf der Property plattgeschlafen und in FFont stehr ien Zeiger in die Pampa.
Besser ist wohl:
FFont.Assign(Value)