SetTimer in einer Klasse

[magicshadow]

Hallöchen.

Ich möchte ein Programm von mir um einige Kb erleichtern und das indem ich die Forms Unit entferne, daher kann ich auch den Delphi timer nicht nutzen (da dieser die Unix Forms referenziert)

Also bin ich auf SetTimer umgestiegen. (Die API Funktion)

Mien Problem ist nun, das ich eine klasse habe, von der ich mehrere Instanzen erzeuge udn jede braucht einen eigenen Timer.

Normale Proceduren kann ich auch als CallBack Proceduren angeben, nur wenn ich eine Prozedur einer Klasse angeben möchte gibt es immer den Fehler "Variable Erforderlich) gibt es eine Möglichkeit dieses zu umgehen, oder zumindest in einer Timer Procedure zu erkennen welche instanz des Timers das Event ausgelöst hat um dann auß einer Liste die entsprechende Klasseninstanz zu holen?

Danke schonmal

[magicshadow]

Also ich hab das problem gelöst, über eine HilfsVariable gehts dann.

Allerdings hab ich jetzt ein andrees Problem.

Ich bin am Programieren einer dll, darin nutze ich Klassen und eine davon soll mit hilfe von SetTimer eine ihrer proceduren aufrufen, klappt soweit auch recht gut, nur wenn ich dann auf eine Variable dieser Klasse zugreifen möchte gibt es einen Fehler (und die Procedure wird ohne Ausgabe beendet)

Kennt einer dasProblem und weiß wie man es (möglichst ohne ein Fenster mit WindowProcedure zu erstellen) lösen kann?

Wäre super.

Ach ja, ich rufe SetTimer so auf:

Delphi-Quellcode:

type
oTimerProc = procedure of object;
var
hTimer : longint;
procedure TWas.TimerProc;
begin
...
end;

procedure TWas.InitTimer;
var 
TimerVar: oTimerProc;
begin
TimerVar := self.TimerProc;
hTimer := SetTimer(0, 0, 1000, @TimerVar);
end;

wenn ich den code in einer exe ausführe geht es, nur in einer dll macht es probleme.

PS: Ich nutze in der Dll einen eigenen Threat.

[edit=r_kerber]Code- durch Delphi-Tags ersetzt. Mfg, r_kerber[/edit]

[Tryer]

Seltsam das Du es überhaupt so zum laufen bekommst, ich würde da mit Zugriffsverletzungen rechnen

Aus der Win32-Hilfe:

Zitat:

The TimerProc function is an application-defined callback function that processes WM_TIMER messages.

VOID CALLBACK TimerProc(

HWND hwnd, // handle of window for timer messages
UINT uMsg, // WM_TIMER message
UINT idEvent, // timer identifier
DWORD dwTime // current system time
);

Wie Du vielleicht erkennst hat das nicht viel mit Deiner Methoden TWas.TimerProc zu tun.

Hier mal noch eine andere Lösungsmöglichkeit, die zudem den Vorteil bietet das man innerhalb der (globalen) Callback-Prozedur über "dwUser" auch die Möglichkeit hat auf eine Objektinstanz zuzugreifen:

Delphi-Quellcode:

program Project1;

uses
  Windows,
  Classes,
  Types,
  mmSystem,
  SysUtils;

type
   TLittleTimer = class(TObject)
   private
     FCount: Cardinal;
     FTimerID: Cardinal;
   public
     constructor Create;
     destructor Destroy; override;
     function IsActive: Boolean;
     procedure Pieps;
     property TimeCallCount: Cardinal read FCount;
     procedure Start(Delay: Cardinal);
     procedure Stop;
  end;

var
  Was: TLittleTimer;

{ CallBack-Prozedur
  Obwohl diese Prozedur global deklariert ist erlaube ich mir auf 
  die als private deklarierten Felder von TLittleTimer zuzugreifen, 
  schliesslich ist diese Routine fester Bestandteil von TLittleTimer.
  In gleicher Weise liesse sich hier auch ein Event auslösen. 
}
procedure MyTimeCallBack(uID, uMsg: Cardinal; dwUser, dw1, dw2: DWord); stdcall;
var
  Tmr: TLittleTimer;
begin
  Tmr := TLittleTimer(dwUser);
  Inc(Tmr.FCount);
  Tmr.Pieps;
end;

{ TLittleTimer }

constructor TLittleTimer.Create;
begin
  inherited;
  FCount := 0;
  FTimerID := 0;
end;

destructor TLittleTimer.Destroy;
begin
  Stop;
  inherited;
end;

function TLittleTimer.IsActive: Boolean;
begin
  Result := FTimerID <> 0;
end;

procedure TLittleTimer.Pieps;
begin
  Beep;
end;

procedure TLittleTimer.Start(Delay: Cardinal);
begin
  if FTimerID = 0 then
  begin
    FCount := 0;
    // Timer starten und eigene Instanz in dwUser übergeben
    FTimerID := TimeSetEvent(Delay, 0, @MyTimeCallBack, Cardinal(Self),
      TIME_PERIODIC);
  end;
end;

procedure TLittleTimer.Stop;
begin
  if FTimerID <> 0 then
    TimeKillEvent(FTimerID);
end;
{------------------------------------------------------------------------------}

begin
  Was := TLittleTimer.Create;
  try
    Was.Start(500);
    if Was.IsActive then
    begin
      while Was.TimeCallCount < 5 do
      begin
        Sleep(1);
        DoSomething;
      end;
    end;
  finally
    Was.Free;
  end;
end.

"TimeSetEvent", "TimeKillEvent" und "TimeProc" sind die passenden Schlagworte in der Win32-Hilfe.

MfG,
Tryer

[neolithos]

Für SetTimer braucht man auf alle fälle ein Fenster-Handle. TimerProc leitet ja bloß die Nachricht um. Du solltest etwas an deinem Konzept feilen.

Vorschlag:

Delphi-Quellcode:

ITimeEvent = interface 
  procedure Tick;
end;

SetTimer(WinHandle, Integer(Was), 1000, nil); in WM_TIMER-Handler

(TObject(wParam) as ITimeEvent).Tick; Es kann auch einfacher gelöst werden.