2 verschiedene WndProcs

[Cöster]

Hi!

Es gibt zwei verschiedene Methoden namens WndProc:

1. procedure TControl.WndProc(var Message: TMessage); 2. function WndProc(hWnd: Integer; Message, wParam, lParam: LongInt): LongInt; stdcall; Die erste wird oft überschrieben, die zweite findet sich auch mit anderen Parameter-Bezeichnern und Typ-Namen (wobei die Typen die selben sind).

Meine Fragen (mit der Beantwortung werden wahrscheinlich noch mehr dazukommen ):

1. Wie wird die Funktion (zweite) im Interface aufgeführt?
2. Worin ist der Unterschied zwischen den beiden Methoden?

[Luckie]

Nun ja, die erste ist eine Methode der Klasse TControl und die zweite ist die Fensterprozedur eines Programmes ohne VCL. Siehe dazu auch meine "Win32-API Tutorials für Delphi".

[jbg]

Zitat von Luckie:

die zweite ist die Fensterprozedur eines Programmes ohne VCL.

Dann hast du wohl die StdWndProc der VCL übersehen

Die zweite ist die Fensterprozedur, so wie sie Windows braucht. Die erste ist das was die VCL mittels der Controls.pas:StdWndProc für die TControl Klasse umsetzt.

[Luckie]

Zitat von jbg:

Dann hast du wohl die StdWndProc der VCL übersehen

Nope. Aber dann wäre es wieder eine Methode der Klasse TForm, was natürlcih dann auch wieder die Fensterprozedur darstellt.

[Cöster]

Wenn ich also die VCL benutze, kann ich ruhig die Prozedur von TControl (bzw. TCustomForm) überschreiben?

[Luckie]

Kommt drauf an, was du vor hast.

[Cöster]

Ich krieg es nicht gebacken

Ich will einen Message-Loop bauen, mein PC will aber nicht, was ich will. Sobald der Loop startet, ist das Programm reaktionsunfähig und kann nur noch über "Der Debugger läuft gerade. Beenden?" beendet werden. Den Code für den Loop hab ich mir hier abgeguckt.

Mein Code ist im Anhang.

[Luckie]

Keine Ahnung, was das Programm machen soll, aber ich habe es mal korrigiert und kommentiert:

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TRealPoint = record
    X: Single;
    Y: Single;
  end;

  TForm1 = class(TForm)
    PaintBox1: TPaintBox;
    procedure FormCreate(Sender: TObject);
    procedure PaintBox1Click(Sender: TObject);
    procedure PaintBox1Paint(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    FBitmap: TBitmap;
    FFinished: Boolean;
    FLastRenderTime: Cardinal;
    FPos: TRealPoint;
    procedure Render;
    procedure Run;
  public
  end;

var
  Form1             : TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FBitmap := TBitmap.Create;
  FBitmap.Width := 20;
  FBitmap.Height :=  20;
  with FBitmap.Canvas do
  begin
    Brush.Color := clRed;
    Pen.Color := clRed;
    Ellipse(0, 0, 20, 20);
  end;
  FPos.X := 0;
  FPos.Y := 0;
  DoubleBuffered := True;
end;

procedure TForm1.PaintBox1Click(Sender: TObject);
begin
  Run;
  FLastRenderTime := timeGetTime;
end;

procedure TForm1.PaintBox1Paint(Sender: TObject);
begin
  BitBlt(PaintBox1.Canvas.Handle, Round(FPos.X), Round(FPos.Y), 20, 20, FBitmap.Canvas.Handle, 0, 0, SRCCOPY);
end;

procedure TForm1.Render;
var
  TimeDiff          : Integer;
begin
  TimeDiff := timeGetTime - FLastRenderTime;
  FPos.X := FPos.X + TimeDiff / 3;
  PaintBox1.Invalidate;
  // MP: An dieser Stelle überflüssig
  //Application.ProcessMessages;
  Inc(FLastRenderTime, TimeDiff);
end;

procedure TForm1.Run;
// MP:
//var
//  Message           : TMsg;
begin
  while not FFinished do
  begin
    // MP: Warum nimmst du nicht Application.ProcessMessages?
    Application.ProcessMessages;
      // MP: Von welchen Fenster soll PeekMessage denn die Nachrichten an die Fenster-Prozedur weiterleiten,
      // wenn du null als Fensterhandle angibst?
      // Und an welcher Stelle hast du die (nicht vorhandene) Fensterklasse mit deiner Fenster-Prozedur verknüpft?
      // Du mischt hier VCL und 'NonVCL' Code, was zum einem so nicht funktioniert und zum anderen nicht gemacht
      // werden sollte.
//    while PeekMessage(Message, 0, 0, 0, PM_REMOVE) do
//    begin
//      TranslateMessage(Message);
//      DispatchMessage(Message);
//    end;
    // MP: Dein Hauptthread braucht 100% CPU-Last, dass da nichts mehr reagiert, ist kein Wunder.
    Sleep(1);
    Render;
  end;
end;

// MP: Was soll das? Wird doch nie aufgerufen. Und warum implementierst du eine Fenster-Prozedur,
// wenn du mit der VCL arbeitest?
//function WndProc(hWnd: Integer; Message, wParam, lParam: Longint): Longint; stdcall;
//begin
//  Result := 0;
//  case Message of
//    WM_DESTROY: PostQuitMessage(0);
//    WM_CLOSE: begin
//        Form1.FFinished := True;
//        DestroyWindow(hWnd);
//      end
//  else Result := DefWindowProc(hWnd, Message, wParam, lParam);
//  end;
//end;

// MP: FFinished auf TRUE setzen, sonst kann das Fenster nicht geschlossen werden.
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  FFinished := True;
end;

end.

[edit=Admin] Mfg, Daniel[/edit]

[Cöster]

Danke für die Kommentierung.

Ich wollte mit dem Programm einfach nur die Bewegung eines Kreises auf einer PaintBox anhand eines Message-Loops realisieren. jfheins hat mir hier den Hinweis gegeben, dass das idR so gemacht wird und mich per PN auf den oben verlinkten Beitrag hingewiesen.
Macht die While-not-PeekMessage-Schleife genau das gleiche wie Application.ProcessMessages? Benutzt man diese Schleife nur bei nonVCL-Programmierung?
Dann wär das doch eigentlich genau das Prinzip, das ich in meinem Timer verwendet hab, nur das ich es nicht in eine Klasse auslagern sollte.