1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:

 function IsWinXP: Boolean;
begin
  Result := (Win32Platform = VER_PLATFORM_WIN32_NT) and
    (Win32MajorVersion = 5) and (Win32MinorVersion = 1);
end;

function IsWin2k: Boolean;
begin
  Result := (Win32MajorVersion >= 5) and
    (Win32Platform = VER_PLATFORM_WIN32_NT);
end;

function IsWinNT4: Boolean;
begin
  Result := Win32Platform = VER_PLATFORM_WIN32_NT;
  Result := Result and (Win32MajorVersion = 4);
end;

function IsWin3X: Boolean;
begin
  Result := Win32Platform = VER_PLATFORM_WIN32_NT;
  Result := Result and (Win32MajorVersion = 3) and
    ((Win32MinorVersion = 1) or (Win32MinorVersion = 5) or
    (Win32MinorVersion = 51));
end;

function GetRunningProcessesIDList(List: TStrings): Boolean;
var SnapProcHandle: THandle;
    ProcEntry: TProcessEntry32;
    NextProc: Boolean;
    PIDs: array [0..1024] of DWORD;
    Needed: DWORD;
    I: Integer;
begin
  if IsWin3X or IsWinNT4 then
    begin
      SnapProcHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      Result := (SnapProcHandle <> INVALID_HANDLE_VALUE);

      if Result then
        try
          ProcEntry.dwSize := SizeOf(ProcEntry);
          NextProc := Process32First(SnapProcHandle, ProcEntry);
          while NextProc do
            begin
              List.Add(IntToSTR(ProcEntry.th32ProcessID));
              NextProc := Process32Next(SnapProcHandle, ProcEntry);
            end;
        finally
          CloseHandle(SnapProcHandle);
        end;
    end
  else
    begin
      Result := EnumProcesses(@PIDs, SizeOf(PIDs), Needed);

      if Result then
        for I := 0 to (Needed div SizeOf(DWORD)) - 1 do
          List.Add(IntToStR(PIDs[i]));
    end;
end;

function ProcessFileName(PID: DWORD): string;
var Handle: THandle;
begin
  Result := '';
  Handle := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, False, PID);

  if Handle <> 0 then
    try
      SetLength(Result, MAX_PATH);

      if GetModuleFileNameEx(Handle, 0, PChar(Result), MAX_PATH) > 0 then
        SetLength(Result, StrLen(PChar(Result)))
      else
        Result := '';
    finally
      CloseHandle(Handle);
    end;
end;

function IsFilePath(ProcessID: DWORD; Path: String): Boolean;
var FileName: String;
begin
  case ProcessID of
    0: FileName := RsSystemIdleProcess;
    2: if IsWinNT4 then
         FileName := RsSystemProcess
       else
         FileName := ProcessFileName(ProcessID);
    8: if IsWin2k or IsWinXP then
         FileName := RsSystemProcess
       else
         FileName := ProcessFileName(ProcessID);
    else FileName := ProcessFileName(ProcessID);
  end;

  Result := UpperCase(FileName) = UpperCase(Path);
end;


function GetWindowHandle(ProcessID: DWORD; var Handle: THandle): Boolean;

function EnumerateThreadWindows(Wnd: HWND; Data: lParam): BOOL;
begin
  Handle := Wnd;
  Result := False;
end;

begin
  Result := EnumThreadWindows(ProcessID, @EnumerateThreadWindows, 0);
end;

{var PID: DWORD;
begin
  Result := False;
  Handle := GetForegroundWindow;

  while (Handle <> 0) and (not Result) do
    begin
      GetWindowThreadProcessId(Handle, @PID);
      if PID = ProcessID then
        Result := True
      else
        Handle := GetNextWindow(Handle, GW_HWNDNEXT);
    end;
end;                  }

//-------------------------------------------------------

var LST: TStringList;
    PID: DWORD;
    i: Integer;
    Path: String;
    WindowHandle: THandle;


// folgendes ist nur ein Codeausschnitt

LST := TStringList.Create;

if GetRunningProcessesIDList(LST) then
  begin
    PID := INVALID_HANDLE_VALUE;

    for i := 0 to LST.Count - 1 do
      if IsFilePath(StrToInt(LST[i]), Path]) then
         PID := StrToInt(LST[i]);

    if PID <> INVALID_HANDLE_VALUE then
      if GetWindowHandle(PID, WindowHandle) then  // <--- Dise Funktion scheint noch ein Prolem zu sein
        SendMessage(WindowHandle, WM_CLOSE, 0, 0)
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

    Function TFormx.KillTask(ExeFileName: string): Integer;
    const
      PROCESS_TERMINATE = $0001;
    var
      ContinueLoop: BOOL;
      FSnapshotHandle: THandle;
      FProcessEntry32: TProcessEntry32;
    begin
      Result := 0;
      FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      FProcessEntry32.dwSize := SizeOf(FProcessEntry32);
      ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);

      while Integer(ContinueLoop) <> 0 do
      begin
        if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) =
          UpperCase(ExeFileName)) or (UpperCase(FProcessEntry32.szExeFile) =
          UpperCase(ExeFileName))) then
          Result := Integer(TerminateProcess(OpenProcess(PROCESS_TERMINATE,BOOL(0),FProcessEntry32.th32ProcessID), 0));
        ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
      end;
      CloseHandle(FSnapshotHandle);
    end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

function GetProcessNameFromWnd(Wnd: HWND): string;
var
  List: TStringList;
  PID: DWORD;
  I: Integer;
begin
  Result := '';
  if IsWindow(Wnd) then
  begin
    PID := INVALID_HANDLE_VALUE;
    GetWindowThreadProcessId(Wnd, @PID);
    List := TStringList.Create;
    try
      //Alle Prozesse durchegehn
      if RunningProcessesList(List, True) then
      begin
        I := List.IndexOfObject(Pointer(PID));
        if I > -1 then
          Result := List[I];
      end;
    finally
      List.Free;
    end;
  end;
end;					

1:

export; {$ifdef Win32} stdcall; {$endif}