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:

procedure TForm1.Button1Click(Sender: TObject);
var
  Anzahl : integer;
begin
  Anzahl := TNA_Refresh;
  Label1.Caption := 'Gelöschte Icon-Leichen: ' + IntToStr(Anzahl);
end;

// uses CommCtrl;
function TForm1.TNA_Refresh: integer;
var
  wnd            : HWND;
  AnzahlIcons    : integer;
  Schleife       : integer;
  Koordinaten    : TPoint;
  AltKoordinaten : TPoint;
  pID            : cardinal;
  hProg          : THandle;
  Rect           : TRect;
  pAdr           : Pointer;
  Gelesen        : cardinal;
  AnzahlBytes    : integer;
begin
  // Result initialisieren. "- 1" = Fehler
  Result := - 1;

  // Fenster finden (Windows 7)
  wnd :=  FindWindow('Shell_TrayWnd', nil);
  wnd :=  FindWindowEx(wnd, 0, 'TrayNotifyWnd', nil);
  wnd :=  FindWindowEx(wnd, 0, 'SysPager', nil);
  wnd :=  FindWindowEx(wnd, 0, 'ToolbarWindow32', nil);

  if wnd <> 0 then
    begin
      // akt. Mauskoordinaten merken
      GetCursorPos(AltKoordinaten);

      // Anzahl der "Icons" ermitteln
      AnzahlIcons := SendMessage(wnd, TB_ButtonCount, 0, 0);

      // Prozess ermitteln, der die TaskbarNotificationArea verwaltet, und öffnen.
      GetWindowThreadProcessID(wnd, @pID);

      hProg := OpenProcess(Process_VM_Operation
                             or Process_VM_Read
                             or Process_VM_Write,
                           false,
                           pID);

      // Speichergröße festlegen und im anderen Prozess den Speicher anfordern.
      AnzahlBytes := SizeOf(Rect);

      pAdr := VirtualAllocEx(hProg,
                         nil,
                         AnzahlBytes,
                         MEM_Reserve
                           or MEM_Commit,
                         Page_ReadWrite);

      for Schleife := AnzahlIcons - 1 downto 0 do
        begin
          // Position des "Icons" abfragen und aus dem anderen Prozess auslesen.
          SendMessage(wnd, TB_GetRect, Schleife, integer(pAdr));

          ReadProcessMemory(hProg,
                            pAdr,
                            @Rect,
                            AnzahlBytes,
                            Gelesen);

          // Die Koordinaten des Icons beziehen sich auf den Bereich der Taskbar-
          // NotificationArea und sind deshalb in Koordinaten für den Desktop-Screen
          // umzurechnen. Zur Sicherheit addiere ich hier jeweils 3 Pixel.
          Koordinaten.X := Rect.Left + 3;
          Koordinaten.Y := Rect.Top + 3;
          Windows.ClientToScreen(wnd, Koordinaten);
          SetCursorPos(Koordinaten.X, Koordinaten.Y);
        end;

      // aufräumen und Speicher freigeben
      VirtualFreeEx(hProg,
                    pAdr,
                    0,
                    MEM_Release);
      CloseHandle(hProg);

      // Maus wieder auf die alten Koordinaten setzen
      SetCursorPos(AltKoordinaten.X, AltKoordinaten.Y);

      // Anzahl gelöschter "Icons" ermitteln
      Result := AnzahlIcons - SendMessage(wnd, TB_ButtonCount, 0, 0);
    end;
end;					

1:

ProcPath:= 'C:\Programme\iSaver\iSaverCtrl.exe';					

1:

if SameText(ProcPath, GetProcPath(IconData.Wnd)) then					

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:

unit Main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, CommCtrl, ShellAPI;

type
  TMainform = class(TForm)
    Refresh: TButton;
    Label1: TLabel;
    procedure RefreshClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    function TNA_Refresh : integer;
    function SuchenTNAWindow : HWnd;
  end;

var
  Mainform: TMainform;

implementation

{$R *.dfm}

function TMainform.TNA_Refresh : integer;
var
  Wnd          : HWnd;            // Fenster-Handle des TNA-Bereichs
  AnzahlIcons  : integer;         // Anzahl Icons im TNA-Bereich
  Schleife     : integer;         // Schleifenvariable
  pID          : THandle;         // Handle für Prozess, der die TNA verwaltet
  HProcess     : THandle;         // OpenProcess-Handle zum pID-Prozess
  pMemory      : Pointer;         // Zeiger auf reservierten Speicher im TNA-Prozess
  AnzahlBytes  : integer;         // Anzahl der im TNA-Prozess zu reservierenden Bytes
  Gelesen      : cardinal;        // Anzahl gelesener Bytes;
  TB           : TTBButton;       // für ReadProcessMemory
  IconData     : TNotifyIconData; // für ReadProcessMemory
begin
  Result := - 1;
  AnzahlBytes := 256;
  IconData.cbSize:= SizeOf(TNotifyIconData);

  Wnd := SuchenTNAWindow;
  if Wnd <> 0 then
    begin
      AnzahlIcons := SendMessage(Wnd, TB_ButtonCount, 0, 0);

      // TNA-Prozess öffnen
      GetWindowThreadProcessId(Wnd, @pID);

      HProcess := OpenProcess(Process_VM_Operation
                                or Process_VM_Read
                                or Process_VM_Write,
                              false,
                              pID);

      // Speicher im TNA-Prozess reservieren.
      pMemory := VirtualAllocEx(HProcess,
                                nil,
                                AnzahlBytes,
                                MEM_Reserve
                                  or MEM_Commit,
                                Page_ReadWrite);

      // Jedes TNA-Icon daraufhin prüfen, ob das Handle "IconData.Wnd"
      // existiert. Wenn nicht, dann liegt eine Icon-"Leiche" vor,
      // die gelöscht wird.
      for Schleife := AnzahlIcons - 1 downto 0 do
        begin
          if SendMessage(Wnd, TB_GetButton, Schleife, Cardinal(pMemory)) <> 0 then
            if ReadProcessMemory(HProcess,
                                 pMemory,
                                 @TB,
                                 SizeOf(TB),
                                 Gelesen) then
              if ReadProcessMemory(HProcess,
                                   Pointer(TB.dwData),
                                   @IconData.Wnd,
                                   SizeOf(IconData.Wnd) + SizeOf(IconData.uID),
                                   Gelesen) then
                if not IsWindow(IconData.Wnd) then          // Icon-Leiche ???
                  Shell_NotifyIcon(NIM_Delete, @IconData);  // Icon löschen
        end;

      // aufräumen
      VirtualFreeEx(HProcess,
                    pMemory,
                    0,
                    MEM_Release);
      CloseHandle(HProcess);

      // Anzahl gelöschter Icons ermitteln
      Result := AnzahlIcons - SendMessage(wnd, TB_ButtonCount, 0, 0);
    end;
end;

procedure TMainform.FormCreate(Sender: TObject);
begin
  // Speicherlecks beim Programmende anzeigen
  ReportMemoryLeaksOnShutdown := true;
end;

function TMainform.SuchenTNAWindow : HWnd;
begin
  // Sollte bei allen Windowsversionen ab XP gleich sein.

  Result :=  FindWindow('Shell_TrayWnd', nil);
  Result :=  FindWindowEx(Result, 0, 'TrayNotifyWnd', nil);
  Result :=  FindWindowEx(Result, 0, 'SysPager', nil);
  Result :=  FindWindowEx(Result, 0, 'ToolbarWindow32', nil);
end;

procedure TMainform.RefreshClick(Sender: TObject);
var
  Ergebnis : integer;
begin
  Ergebnis := TNA_Refresh;
  if Ergebnis > - 1 then
    Label1.Caption := 'Gelöschte Icons: ' + IntToStr(Ergebnis)
  else
    Label1.Caption := 'TNA-Fenster nicht gefunden!';
end;

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:
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:

function FindTNAWindow: HWND;
begin
  Result := FindWindow('Shell_TrayWnd', nil);
  Result := FindWindowEx(Result, 0, 'TrayNotifyWnd', nil);
  Result := FindWindowEx(Result, 0, 'SysPager', nil);
  Result := FindWindowEx(Result, 0, 'ToolbarWindow32', nil);
end;

function IsWow64Process: Boolean;
type
  TIsWow64Process = function(hProcess: THandle; var Wow64Process: BOOL): BOOL; stdcall;
var
  Value: BOOL;
  IsWow64ProcessFunc: TIsWow64Process;
begin
  IsWow64ProcessFunc := GetProcAddress(GetModuleHandle('kernel32'), 'IsWow64Process');
  Result := Assigned(IsWow64ProcessFunc);
  if Result then
  begin
    if not IsWow64ProcessFunc(GetCurrentProcess, Value) then
      raise Exception.Create('Bad process handle');
    Result := Value;
  end;
end;

function RefreshTNAIcons: Integer;
type
  TTBButton64 = packed record
    iBitmap: Integer;
    idCommand: Integer;
    fsState: Byte;
    fsStyle: Byte;
    bReserved: array [1 .. 6] of Byte;
    dwData: Int64;
    iString: Int64;
  end;
var
  TNAWindow: HWND; // Fenster-Handle des TNA-Bereichs
  i, IconCount: Integer; // Anzahl Icons im TNA-Bereich
  TrayProcessID: THandle; // Handle für Prozess, der die TNA verwaltet
  TrayProcessHandle: THandle; // OpenProcess-Handle zum pID-Prozess
  pMemory: Pointer; // Zeiger auf reservierten Speicher im TNA-Prozess
  BufferSize, // Anzahl der im TNA-Prozess zu reservierenden Bytes
  ReadBytes: Cardinal; // Anzahl gelesener Bytes;
  TB: TTBButton; // für ReadProcessMemory
  TB64: TTBButton64; // 64-Bit
  IconData: TNotifyIconData; // für ReadProcessMemory
  ReadSuccessful, UseWow64Data, CanProcessEntry: Boolean;
begin
  Result := -1;
  BufferSize := 256;
  IconData.cbSize := SizeOf(TNotifyIconData);

  TNAWindow := FindTNAWindow;
  if TNAWindow <> 0 then
  begin
    IconCount := SendMessage(TNAWindow, TB_BUTTONCOUNT, 0, 0);
    // TNA-Prozess öffnen
    GetWindowThreadProcessId(TNAWindow, @TrayProcessID);
    TrayProcessHandle := OpenProcess(PROCESS_VM_OPERATION or PROCESS_VM_READ or PROCESS_VM_WRITE, False,
      TrayProcessID);
    // Speicher im TNA-Prozess reservieren.
    pMemory := VirtualAllocEx(TrayProcessHandle, nil, BufferSize, MEM_RESERVE or MEM_COMMIT, PAGE_READWRITE);
    try
      UseWow64Data := IsWow64Process;
      // Jedes TNA-Icon daraufhin prüfen, ob das Handle "IconData.Wnd"
      // existiert. Wenn nicht, dann liegt eine Icon-"Leiche" vor,
      // die gelöscht wird.
      for i := IconCount - 1 downto 0 do
      begin
        if SendMessage(TNAWindow, TB_GETBUTTON, i, lParam(pMemory)) <> 0 then
          if UseWow64Data then
            CanProcessEntry := ReadProcessMemory(TrayProcessHandle, pMemory, @TB64, SizeOf(TB64), ReadBytes)
              and ReadProcessMemory(TrayProcessHandle, Pointer(TB64.dwData), @IconData.Wnd,
              SizeOf(IconData.Wnd) + SizeOf(IconData.uID), ReadBytes)
          else
            CanProcessEntry := ReadProcessMemory(TrayProcessHandle, pMemory, @TB, SizeOf(TB), ReadBytes) and
              ReadProcessMemory(TrayProcessHandle, Pointer(TB.dwData), @IconData.Wnd,
              SizeOf(IconData.Wnd) + SizeOf(IconData.uID), ReadBytes);
        if CanProcessEntry and not IsWindow(IconData.Wnd) then // Icon-Leiche ???
          Shell_NotifyIcon(NIM_DELETE, @IconData); // Icon löschen
      end;
    finally
      // aufräumen
      VirtualFreeEx(TrayProcessHandle, pMemory, 0, MEM_RELEASE);
      CloseHandle(TrayProcessHandle);
    end;
    // Anzahl gelöschter Icons ermitteln
    Result := IconCount - SendMessage(TNAWindow, TB_BUTTONCOUNT, 0, 0);
  end;
end;