czy inna aplikacja jest zminimalizowana?

podam na przykładzie:
uruchamiam własny program ktory działa w tle i który sprawdza czy został uruchomiony inny proces w ten sposób że podaje się ścieżkę do aplikacji:

function GetProcessFileName(const pID: DWORD): string;
var
  hProc: HWND;
  buffer: array[0..1023] of Char;
  snap: THandle;
  pe32: TProcessEntry32;
begin
  Result := '';

  if (Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion > 3) then
  begin
    hProc := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, False, pID);
    if hProc <> 0 then
    begin
      FillChar(buffer, SizeOf(buffer), 0);
      GetModuleFileNameEx(hProc, 0, buffer, SizeOf(buffer));
      Result := buffer;
    end;
    CloseHandle(hProc);
  end
  else
  begin
    snap := CreateToolHelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    pe32.dwSize := SizeOf(TProcessEntry32);
    if integer(Process32First(snap, pe32)) <> 0 then
      repeat
        if integer(pID) = integer(pe32.th32ProcessID) then
        begin
          Result := pe32.szExeFile;
          Break;
        end;
      until integer(Process32Next(snap, pe32)) = 0;
    CloseHandle(snap);
  end;
end;

function CheckApp(const FileName: string): boolean;
var
  snap: THandle;
  pe32: TProcessEntry32;
begin
  Result := False;

  snap := CreateToolHelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  pe32.dwSize := SizeOf(TProcessEntry32);
  if integer(Process32First(snap, pe32)) <> 0 then
    repeat
      if UpperCase(FileName) = UpperCase(GetProcessFileName(pe32.th32ProcessID)) then
      begin
        Result := True;
        Break;
      end;
    until integer(Process32Next(snap, pe32)) = 0;
  CloseHandle(snap);
end;

poprzez podanie ścieżki do aplikacji sprawdzam sobie czy (jej) proces jest uruchomiony i tu gwóźdź programu :>
potrzebuje wiedziec czy ten uruchomiony proces jest zminimalizowany czy nie ?!?
moze jakos da się to osiąganąć poprzez wyciągnięcie tej informacji z powyższej (pierwszej) funkcji ? ?

Podstawowe pytanie: czy proces może być w ogóle zminimalizowany. Odpowiedź na nie brzmi: nie. To okna, utworzone przez proces mogą być zminimalizowane, nie sam proces. Proces także może nie mieć żadnych skojarzonych okien lub być aplikacją konsolową.

Zadanie: przejrzeć, do których procesów należą poszczególne okna i sprawdzić, czy te, należące do obserwowanej aplikacji, są zminimalizowane.

dobrze, rozumiem już że proces to nie okienko ale praktycznie nie wiem jakich procedur użyć, jakbyś mógł polecić jakie rozwiązanie byłoby zajeiście,
ścieżka do aplikacji powiedzmy że jest 'C:\test.exe' a sama aplikacja jest jak najbardziej okienkowa,
potrzebuje wiedzieć czy 'test.exe' jest zminimalozowany czy nie

co najwyżej czy okno utworzone przez proces 'test.exe' jest zminimalizowane czy nie

to co masz + EnumWindows + GetWindowThreadProcessId + GetWindowState

jeśli to ma działać dla jednego określonego programu to czemu nie użyjesz FindWindow ?

Ja bym nie był pewien tego co napisał Szczawik. Aplikacja zminimalizowana jest ewidentnie inaczej traktowana przez system (większy zrzut pamięci do pliku wymiany). Gdy na przykład wciskamy klawisz "pokaż pulpit" okna znikają tak by pokazać pulpit ale nie są minimalizowane i tego zrzutu z pamięci na dysk nie ma a więc jest wyraźna różnica między aplikacją zminimalizowaną i niezminimalizowana choćby pod tym względem. Trzeba by to dokładniej potestować jak np. zachowuje się aplikacja konsolowa i "bezkonsolowa i bezformowa" pod tym względem kiedy wywołamy w niej metody Application.minimize i Application.restore. Ale to ciekawe pytanie, które zadał x-fly. Chętnie poczytam wypowiedzi osób, które być moze znają odpowiedź jak uzyskać taką informację o aplikacji:-)

Masz prawo się ze mną nie zgadzać, ale wystarczy przejrzeć kod metody Application.Minimize, by się przekonać, że po prostu minimalizowane są wszystkie okna (plus zadbano, by nie utracić głównego okna aplikacji):

procedure TApplication.Minimize;
begin
  if not IsIconic(FHandle) then
  begin
    NormalizeTopMosts;
    SetActiveWindow(FHandle);
    DoShowOwnedPopups(False);
    if (MainForm <> nil) and (ShowMainForm or MainForm.Visible)
      and IsWindowEnabled(MainForm.Handle) then
    begin
      SetWindowPos(FHandle, MainForm.Handle, MainForm.Left, MainForm.Top,
        MainForm.Width, 0, SWP_SHOWWINDOW);
      DefWindowProc(FHandle, WM_SYSCOMMAND, SC_MINIMIZE, 0);
    end else
      ShowWinNoAnimate(FHandle, SW_MINIMIZE);
    if Assigned(FOnMinimize) then FOnMinimize(Self);
  end;
end;

To, że aplikacja zminimalizowana tą metodą jest mniejsza wynika z prostej rzeczy: tak napisany jest VCL, a nie system operacyjny. Wystarczy zagłębić się w metody ShowWinNoAnimate, DoShowOwnedPopups oraz NormalizeTopMosts, by jak na dłoni mieć minimalizację poszczególnych popupów i klasycznych okien aplikacji.

to dotyczy nie tylko programów napisanych w delphi ale wielu, wielu, programów. Np. outlook expressa. Czy to też kwestia VCL? Może jednak jest różnica między aplikacją zminimalizowana a niezminimalizowana i pytanie x-fly'a ma sens?

System traktuje aplikacje jako zminimalizowaną, kiedy zminimalizowane jest jej główne okno. Ale minimalizacja nie jest cechą aplikacji tylko tego okna.

Sprawdź w prosty sposób: zbuduj aplikację złożoną z Form1, Form2. W OnShow Form1 wpisz:

Form2.Show();

Uruchom aplikację i zminimalizuj Form2 - zmniejszy się do belki. Przywróć ją i zminimalizuj Form1. Cała aplikacja się zminimalizuje (a Form2 nie przybierze postaci belki, ale zniknie jak całość aplikacji). Ot zagadka - system pokazując pulpit minimalizuje wszystkie, zatem i główne, okna.

A VCL ma bardzo dużo do tego - na 4P kiedyś była dyskusja, w której brałem z resztą udział - miałem aplikację, która przed minimalizacją zajmowała ileśtam pamięci, a po minimalizacji i przywróceniu dużo mniej. Jak pisałem aplikacje w czystym Winapi to takie zmiany były widoczne ale w bardzo niewielkim stopniu. Zapewne wynikały z samego faktu minimalizacji okien.

Ot zagadka - system pokazując pulpit minimalizuje wszystkie, zatem i główne, okna.

Mój outlook zajmuje 2MB z haczykiem ramu. Kiedy wciskam pokaż pulpit, nadal zajmuje tyle samo a kiedy minimalizuję okno outlooka wówczas zajmuje 444Kb. Możesz mi wyjaśnić jak to sie ma do Twojej wiedzy cytowanej przeze mnie na wstępie? :-)

P.S Mam wrażenie że odpowiadasz na posty, nie zadając sobie trudu by je najpierw dokładnie przeczytać. Poza tym w tym temacie nie chodzi o minimalizację i przywrócenie tylko o sam stan bycia aplikacją zminimalizowaną. Ja podaję na podstawie choćby oultook expressa oraz jego minimalizacji poprzez klawisz minimalizujący formę i i poprzez " pokaż pulpit" że są to dwie różne rzeczy. Nie wiem na czym ta różnica polega (ale ona ewidentnie jest i pytanie x-fly'a ma sens) dlatego czekam na posty w tym wątku w nadziei, że się dowiem. :-) No ale Twój post wpierający nieprawdę specjalnie pouczający nie jest.

Czytam dokładnie, ale nie ustosunkowywałem się do twoich dywagacji na temat Minimalizacja a Pokaż pulpit, tylko do wątku głównego tego tematu - czy proces jest minimalizowany czy tylko jego okna. Stąd pewnie niezrozumienie.

Co do twojego tematu: prawdopodobnie (zgaduję, ale wydaje się to bardzo możliwe), opcja pokaż pulpit (dokładnie akcja ToggleDesktop dispatcher'a powłoki) zmienia jedynie kolejność okien w systemie (pulpit daje na przód), przez co żadne z okien nie minimalizuje się (ale dzięki temu możliwe jest łatwe przywrócenie stanu poprzedniego). Minimalizacja nie zapamiętuje, które okna były w jakim stanie, więc przywrócenie okien nie jest możliwe - po prostu wszystkie są minimalizowane.

Skoro przy Pokazaniu pulpitu okna są przesuwane do tyłu, wciąż są niezminimalizowane i zabierają zasoby (choćby pamięć obrazu okna, pewnie znajdzie się jeszcze niejedna rzecz).

Wskaż może w czym napisałem nieprawdę? W tym, że VCL ma ogromny na to wpływ? Bo ma; a ma choćby dlatego, że może pozwalać na buforowanie obrazu wielu komponentów, co przy minimalizacji nie jest potrzebne, a system samodzielnie tego nie robi (nie licząc wyglądu okien).

Dopisane: OK, już wiem, o który fragment Ci chodziło. W zacytowanym fragmencie pokazując pulpit użyłem jako skrót myślowy, by nie pisać minimalizując minimalizuje. Sorry za to, nie chciałem wprowadzić w błąd.

Szczawik, a czy kod który wyżej napisałeś dam rade wykorzystać w kwestii z tematu tematu ?

chodzi mi dokładnie o jeden program czyli
uruchamiam swój, powiedzmy A.exe i on ma sprawdzać w Timerze czy B.exe jest zminimalizowany czy nie, ścieżka do B.exe jest oczywiście znana

wielu rzeczy w programowaniu nie potrafie dlatego się pytam, choć zanim zapytam przeglądam forum od dechy do dechy i gogle wiadomo no ale nie uało mnie sie znaleźć nic co by pomogło

jest taka oto prosta i krótka funkcja, wyszukuje spośród otwartych okien to które ma w nazwie 'Paint'

function EnumWindowsProc(hwnd: HWND; lParam: LPARAM): BOOL; stdcall;
var
TYTUL: array[0..255] of Char;
begin
GetWindowText(hwnd, @TYTUL, 255); //pobranie tekstu okna
if AnsiPos(AnsiString('Paint'), AnsiString(@TYTUL)) <> 0 then
  begin
  { I TUTAJ SPRAWDZENIE CZY hwnd JEST ZMINIMALIZOWANY }
  {? ? ? JAK ? ? ? }
  end;
end;

już tak niewiele zostało do rozwiązania zagadki, tęgie głowy -> pomóżcie

GetWindowPlacement() nie działa poza tym on nie dałby info o stanie okna a GetWindowState() zdaje się że nie istnieje

Oczywiście. Jego celem było pokazanie, czemu Marmar zdawał zaprzeczać w swoim poście, że aplikacja zminimalizowana nie jest traktowana inaczej niż inna aplikacja; po prostu minimalizowane jest okno główne. Zatem minimalizacja nie jest cechą aplikacji a okna.

Druga sprawa; po to również dałem ten kod TApplication.Minimize, byś miał całość funkcji służących do sprawdzania minimalizacji. Nawet nie sprawdziłeś, co robi funkcja w głównym warunku tej metody.

MSDN: IsIconic Function napisał(a)

The IsIconic function determines whether the specified window is minimized (iconic).

Syntax

BOOL IsIconic(
	HWND hWnd
);

Parameters

hWnd
[in] Handle to the window to test.

Return Value

If the window is iconic, the return value is nonzero.

If the window is not iconic, the return value is zero.

:-) wykazałeś się [soczek] jedna linia kodu i wszystko chula bez zarzutu, mam drobną sprawe jeszcze do rozpatrzenia, jakbyś mógł

function EnumWindowsProc(hwnd: HWND; lParam: LPARAM): BOOL; stdcall;
var
TYT: array[0..255] of Char;
begin
GetWindowText(hwnd, @TYT, 255); //pobranie tekstu okna
if AnsiPos(AnsiString('Paint'), AnsiString(@TYT)) <> 0 then
  if IsIconic(hwnd)=True then showmessage('MIN') else showmessage('NORMAL');
end;

zamiast odwoływać się do hwnd po tekście okna lepiej zrobić to za pomocą nazwy procesu,
jak by to wyglądało?

a dokładnie:
znam ścieżkę do aplikacji i potrzebuje jej uchwyt

var
H: hwnd;
begin
H:= CreateToolHelp32Snapshot(TH32CS_SNAPPROCESS, 0);
.......
var
H: THandle;
begin
H := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, False, pID);
.......

które z tych dwóch ?

No to wygląda na to, że jedną kwestię, mianowicie to czy aplikacja jest zminimalizowana czy też nie mamy rozstrzygniętą. Pozostaje sporna kwestia co do tego co to znaczy zminimalizowana i co się dzieję poprzez minimalizację tzn. wcisniecie odpowiedniego klawisza minimalizacji na formie bądź też wywołanie application.minimize. Szczawik twierdzi że minimalizacja aplikacji jest równoważna minimalizacji jej formy głównej i spadek użycia pamięci aplikacji na rzecz zrzucenia jej na dysk jest skutkiem tego że "tak jest
napisane VCL" Ja twierdzę , że to nie prawda, że dzieje się cos więcej i nie ma to nic wspólnego z formą główną programu. Przykład - moim zdaniem dość ewidentny - z outlook expressem nie przekonał Szczawika. Oczywiście kwestia klawisza "pokaż pulpit" też być może jest rozstrzygnięta jeśli przyjąć tłumaczenie Szczawika , które wydaje się mieć sens, to znaczy, że być może (prawdopodobnie), rzeczywiście okno pulpitu jest wyciągane na zewnątrz by pokryć wszystkie inne okna, które minimalizowane nie są i stąd efektu zrzutu pamięci na dysk nie ma bo nie ma minimalizacji. Ok, spoko.

A co się dzieje kiedy aplikacja nie ma formy głównej bądź nawet nie ma żadnej formy w programie i wywoła się application.minimize? No wg. Ciebie szczawik w ogóle nie powinno się nic dziać skoro minimalizacja aplikacji jest równoważna minimalizacji formy głównej a formy głównej nie ma. Niestety to nie prawda. Wywołanie application.minimize powoduje -podobnie jak w przypadku gdy forma główna jest- zrzut pamięci na dysk i zmniejszenie wielkości ramu jaki zajmuje program. A zatem minimalizacja aplikacji to co innego niż minimalizacja formy głównej. Zapewne prawdziwe jest twierdzenie, że podczas minimalizacji aplikacji następuje również minimalizacja formy głównej ale twierdzenie odwrotne nie zawsze ma sens bo nie zawsze istnieje forma główna a wywołanie application.minimize zawsze powoduje jakiś skutek. Można się o tym przekonać pisząc prosty testowy programik bez form z dwoma hotkey'ami podpinając pod jeden application.minimize a pod drugi application.restore i obserwując w menadżerze zadań co się dzieje z pamięcią programu kiedy wciskamy hotkey'e. Jeśli dodatkowo zadeklarujemy jakiegoś np. pchara p na powiedzmy 10 mln byteów i dopiszemy do hotkey'a z zadaniem application.restore, powiedzmy fillchar(p[0],10mln,5) wtedy spróbujemy zmusić system by przy wykonywaniu tej instrukcji zwrócił z dysku do pamięci cały bufor zajmowany przez p i widać będzie że roznica w pamieci miedzy stanem zminimalizowana a niezminimalizowana będzie rzędu 10 mln byteów. I to bez żadnych form w programie. W moim przekonaniu dowodzi to, że minimalizacja to więcej niż operacja na formie i dodatkowo jest to rzecz związana z innym traktowaniem aplikacji(w szczególności jej pamięci) przez system.

Tu właśnie wchodzi VCL. Może tego nie wiesz, ale samo użycie VCL (czyli dodanie do uses nagłówka Forms, gdzie zdefiniowany jest obiekt Application), skutkuje utworzeniem okna - niewidocznego, ale istniejącego!

Proste sprawdzenie:

1. File -> New -> Console Application
2. Project -> Options -> Compiler -> Use Debug DCUs
3. Doprowadź plik kodu do takiej postaci:

uses
  Forms;

begin
end.

Aplikację zmieniliśmy z konsolowej na bezokienkową, która w zasadzie nie powinna robić kompletnie nic.

4. Najedź na słowo Forms i daj Open File at Cursor
5. Postaw Breakpoint w linii 7003 pliku nagłówkowego Forms:

FHandle := CreateWindow(WindowClass.lpszClassName, PChar(FTitle),
      WS_POPUP or WS_CAPTION or WS_CLIPSIBLINGS or WS_SYSMENU
      or WS_MINIMIZEBOX,
      GetSystemMetrics(SM_CXSCREEN) div 2,
      GetSystemMetrics(SM_CYSCREEN) div 2,
      0, 0, 0, 0, HInstance, nil);

6. Skompiluj i uruchom
7. Obserwuj jak kompilator się zatrzymuje na linii.. tworzenia okna. Winapi samo tego nie robi - ten plik jest głównym elementem aplikacji VCL właśnie.

Przekonany?

Nie bardzo rozumiem. Czy Ty twierdzisz że z powodu tego jednego wywołania Createwindow w module Forms, różnica w pamięci jaką zajmuje program po wywołaniu application.minimize a application.restore może wynosić 10MB? Bo dla mnie jest oczywiste, że to pamięć tego wskaźnika p (nie mającego nic wspólnego z createwindow ani z modułem forms) która w jednym przypadku jest w ramie a w drugim jest zrzucona na dysk.

Marmar napisał(a)

A co się dzieje kiedy aplikacja nie ma formy głównej bądź nawet nie ma żadnej formy w programie i wywoła się application.minimize? No wg. Ciebie szczawik w ogóle nie powinno się nic dziać skoro minimalizacja aplikacji jest równoważna minimalizacji formy głównej a formy głównej nie ma. Niestety to nie prawda.

Twierdzę, że samo użycie VCL, by uzyskać dostęp do obiektu Application, skutkuje utworzeniem okna, którego minimalizacja wpływa na zrzut pamięci.

Ok, ja z tym nie polemizuję , pewnie masz rację ale w czym innym rzecz. Mój przykład pokazuje, ze różnica może wynosić 10MB i co to ma wspólnego z vcl?

Pytanie jest inne: Czy dalej dyskutujemy o tym, że proces można zminimalizować czy też minimalizowane jest główne okno; czy może o tym, że VCL ma lub nie wpływ na różnicę zrzucanej pamięci?

Odpowiedź na pierwsze pytanie może dać kod:

uses
  Windows, Messages;

function WndProc(Wnd: HWND; uMsg: UINT; wPar: WPARAM; lPar: LPARAM): LRESULT; stdcall;
begin
Result := 0;
case uMsg of
  WM_DESTROY: PostQuitMessage(0);
  else Result := DefWindowProc(Wnd, uMsg, wPar, lPar);
  end;
end;

var WindowClass:TWndClass;
    Window:THandle;
    Message:TMsg;
begin
ZeroMemory(@WindowClass, sizeof(WindowClass));
WindowClass.lpszClassName := 'Gadżet';
WindowClass.hCursor:=LoadCursor(0, IDC_ARROW);
WindowClass.lpfnWndProc := @WndProc;
WindowClass.hInstance := hInstance;
WindowClass.hbrBackground := COLOR_WINDOW;

RegisterClass(WindowClass);
Window:=CreateWindowEx(0, WindowClass.lpszClassName, 'RSS Gadget', WS_OVERLAPPEDWINDOW or WS_VISIBLE, 100, 100, 200, 200, GetDesktopWindow(), 0, hInstance, nil);
SetWindowPos(Window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE or SWP_NOMOVE);
SetParent(Window, GetDesktopWindow());

while GetMessage(Message, 0, 0, 0) do DispatchMessage(Message);

DestroyWindow(Window);
UnregisterClass(WindowClass.lpszClassName, hInstance);
end.

Wyłącznie jedno okno, bez jakiegokolwiek VCL ani Application.Minimize. Ręczne zminimalizowanie okna daje taki sam zysk, jak wywołanie minimalizacji wszystkich okien. Myślę, że przyjąć zatem możemy, że proces się nie minimalizuje, jedynie jego okna.

Teraz sprawa VCL - nie potrafię tego udowodnić. Być może nie mylisz się i samo VCL ma do tego tylko tyle, że obudowuje Winapi, ale nie wprowadza żadnych zasobów zrzucanych przy minimalizowaniu. Póki nie znajdę niczego takiego, muszę Ci przyznać rację w tej kwestii.

Dopisane: Przyznam, że dyskusja początkowo wydawała mi się zwykłą przepychanką słowną, ale cieszę się, że prowadziła do konstruktywnych konkluzji. [browar]

widze że sie wgryzacie dogłębnie, i bardzo dobrze, 8 raz czytam kod który Szczawik podałeś i wiele z niego nie rozumiem czyli nie znam się na tyle mówiąc prosto, szkoda że jeszcze nie zaszedłem w poznaniu działania tychże funkcji i procedur tak daleko jak wy dlatego wole o ile istnieje prostsze rozwiązanie, niekoniecznie odwołujące się do głęboko ukrytych zaszytych elementów systemu, bardzo podobało mi się jak podałeś funkcje IsIconic która rozwiała połowę problemu, a druga zostaje pomimo waszych szczegółowych i wnikliwych dywagacji dla mnie nierozwiązana, a mianowicie jak pobrać uchwyt 'hwnd' aplikacji do której znam ścieżkę, wtedy mógłbym skorzystać w pełni z funkcji IsIconic(hwnd)

x-fly, chyba GetModuleHandle to robi.

wrzuciłem to do timera

procedure TForm1.Timer1Timer(Sender: TObject);
var
h:hwnd;
begin
h:=GetModuleHandle(pchar('C:\WINDOWS\System32\calc.exe'));   { KALKULATOR }
if isiconic(h)=True then showmessage('true') else ShowMessage('false');
end;

i nie działa, ciągle jest false
jeszcze raz mówie: staram sie ogarniać temat(y) na tyle na ile moja wiedza mi pozwala,
proszę o wsparcie

The GetModuleHandle function returns a module handle for the specified module if the file has been mapped into the address space of the calling process
piszą coś że funkcja zwraca uchwyt modułu (czyli?) jeśli plik został zmapowany do/pod adres/bufor adresu? wywołującego go procesu

pomijając moje spekulacje i tłumaczenia na polski może ktoś potrafi rozwinąć kwestie pobierania uchwytu głównego okna programu jeśli znana jest do niego ścieżka ?!?

zwraca false, bo ta funkcja działa w inny sposób. proces/wątek to nie okno, nie może być zminimalizowany (tak jak Szczawik napisał). isIconic działa tylko i wyłącznie dla uchwytów okien i nie ma co się dziwić, tylko one mogą być zminimalizowane. poza tym co innego proces, a co innego moduł. moduł tym bardziej nie może być zminimalizowany, przecież to tylko obszar pamięci.

robisz tak: pętla po wszystkich procesach, dla każdego z procesów pętla po jego wątkach, dla każdego z wątków pętla po jego oknach (EnumThreadWindows). ostatnia pętla da Ci uchwyt do okna - z nim będziesz wiedział co dalej zrobić (?).

staram sie.... ogarniać... i nie zadawac za dużo zbędnych pytań żeby nie iść na łatwizne (gotowce)
jednak pewnych spraw nie wiem i nie znam wiec pytam...
napisałeś:
pętla po wszystkich procesach (funkcją EnumWindowsProc ?)
dla każdego z procesów pętla po jego wątkach (jaką funkcją ?)
dla każdego z wątków pętla po jego oknach (EnumThreadWindows)
ostatnia pętla da Ci uchwyt do okna (czyli w EnumThreadWindows sprawdze IsIconic ?)

jakby to mniej wiecej wyglądało w całości ?

i jakby co to dzieki chłopaki z góry za poświęcAny czas ;-)

chłopie, nie umiesz wylistować procesów, a zabierasz się za coś takiego?...
enumwindowsproc jak sama nazwa wskazuje służy do wylistowania OKIEN, nie procesów. zapoznaj się z createToolhelp32Snapshot, process32First/Next. tak dostaniesz procesy. createToolhelp32Snapshot i thread32First/Next da Ci wszystkie wątki w systemie; jeśli potrzebujesz tylko wątki i id ich procesów, to process32First/Next nie jest Ci potrzebne.
opis części funkcji masz na 4p, reszta jest na msdn. tu masz przykład użycia wszystkich wymienionych funkcji: http://download.4programmers.net/wtop.zip .

ekstra [soczek]
sprawdze na czasie ktory ostatnio się sporo zawęził stąd brak okazji do odpalenia delfiego