Francis carlos

Março 11, 2011

tente esse
http://www.delphi-jedi.org/files/darth/HeadConv.zip
abraço

não é bem isso

esse programa parece que da load em dll c+

o que eu quero é comverter o code esse programa num converte .cpp nem .h

Março 10, 2011

Ola!!

já tentei usar um programa C2 Delphi pra converter + não ficou muito bom.

quero por este code em uma dll

#define WINNT 1 // Define for using EndTask API
#include <windows>
#include <conio>
#include <stdio>
struct ProcInfo
{
HWND hWnd;
DWORD dwProcId;
CHAR szTitle[255];
CHAR szClass[255];
};
void main()
{
DWORD dwProcId;
HWND hWnd;
ProcInfo mProc[255];
int mIdList[255];
int nCount = 0;
int nPID = 0;
int i = 0;

printf("Detectação de Processos Ocultos\n");
printf("Author: SNOT [snot@skinsmuonline.com]\n");
printf("Copyright ©SNOT, 2010 - Todos os Direitos Reservados\n\n");

hWnd = FindWindow(0,0);
while( hWnd > 0)
{
if (GetParent(hWnd) == 0) // && IsWindowVisible(hWnd)
{
GetWindowThreadProcessId(hWnd, &dwProcId);
// Kiem tra xem OpenProcess co bi chan bang Hooking khong ?
if (!OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcId))
{
mProc[nCount].hWnd = hWnd;
mProc[nCount].dwProcId = dwProcId ;
GetWindowTextA(hWnd, mProc[nCount].szTitle, 255);
GetClassNameA(hWnd, mProc[nCount].szClass, 255);
printf("%2d. Processo Id: %d\n - Nome da Classe: %s\n - Janela Titulo: %s\n",
nCount+1, dwProcId, mProc[nCount].szClass, mProc[nCount].szTitle);
printf(" - Janela Encontrada: 0x%X\n - Status Janela: %s\n\n",
hWnd, IsWindowVisible(hWnd) ? "Shown" : "Hidden");
nCount++;
for (i = 0; i <nPID> 0)
{
printf("\n<?> Você Deseja Finalizar Todas (Y/N): ");
CHAR c = getchar();
if (c == 'Y' || c == 'y')
{
for (i = 0; i < nCount; i++)
{
if (IsWindow(mProc.hWnd)) // Cua so nay con ton tai khong ?
{
// Thu tat lan luot bang 4 buoc ?
SendMessageA(mProc.hWnd, WM_CLOSE, 0, 0); // 1. Close
SendMessageA(mProc.hWnd, WM_QUIT, 0, 0); // 2. Quit
SendMessageA(mProc.hWnd, WM_DESTROY, 0, 0); // 3. Destroy
EndTask(mProc.hWnd, FALSE, TRUE); // 4. EndTask
printf("\n [+] Encontrado Janelas 0x%08X de Processos de ID %4d. Terminado: ",
mProc.hWnd, mProc.dwProcId);
printf( IsWindow(mProc.hWnd) ? "Error" : "OK" ); // Kiem tra lai ket qua ?
}
}
}
}
printf("\n\nVISITE MEU WEBSITE:\n\n");
printf(" [+] http://www.google.com.br");
getch();
}

Fevereiro 9, 2011

ola ajudem com esse code

gostaria que convertecem em delphi...

#define WINNT 1 // Define for using EndTask API
#include <windows.h>
#include <conio.h>
#include <stdio.h>
struct ProcInfo
{
HWND hWnd;
DWORD dwProcId;
CHAR szTitle[255];
CHAR szClass[255];
};
void main()
{
DWORD dwProcId;
HWND hWnd;
ProcInfo mProc[255];
int mIdList[255];
int nCount = 0;
int nPID = 0;
int i = 0;

printf("Detectação de Processos Ocultos\n");
printf("Author: SNOT [snot@skinsmuonline.com]\n");
printf("Copyright ©SNOT, 2010 - Todos os Direitos Reservados\n\n");

hWnd = FindWindow(0,0);
while( hWnd > 0)
{
if (GetParent(hWnd) == 0) // && IsWindowVisible(hWnd)
{
GetWindowThreadProcessId(hWnd, &dwProcId);
// Kiem tra xem OpenProcess co bi chan bang Hooking khong ?
if (!OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcId))
{
mProc[nCount].hWnd = hWnd;
mProc[nCount].dwProcId = dwProcId ;
GetWindowTextA(hWnd, mProc[nCount].szTitle, 255);
GetClassNameA(hWnd, mProc[nCount].szClass, 255);
printf("%2d. Processo Id: %d\n - Nome da Classe: %s\n - Janela Titulo: %s\n",
nCount+1, dwProcId, mProc[nCount].szClass, mProc[nCount].szTitle);
printf(" - Janela Encontrada: 0x%X\n - Status Janela: %s\n\n",
hWnd, IsWindowVisible(hWnd) ? "Shown" : "Hidden");
nCount++;
for (i = 0; i < nPID; i++)
if (dwProcId == mIdList) // Kiem tra co chua ?
break;
if (i == nPID)
mIdList[nPID++] = dwProcId; // Cho vao danh sach
}
}
hWnd = GetWindow(hWnd, GW_HWNDNEXT); // Chuyen sang cua so ke tiep
}
printf("\n=> Detectado %d Janelas %d Processos Ocultos(HIDE).\n", nCount, nPID);
if (nCount > 0)
{
printf("\n<?> Você Deseja Finalizar Todas (Y/N): ");
CHAR c = getchar();
if (c == 'Y' || c == 'y')
{
for (i = 0; i < nCount; i++)
{
if (IsWindow(mProc.hWnd)) // Cua so nay con ton tai khong ?
{
// Thu tat lan luot bang 4 buoc ?
SendMessageA(mProc.hWnd, WM_CLOSE, 0, 0); // 1. Close
SendMessageA(mProc.hWnd, WM_QUIT, 0, 0); // 2. Quit
SendMessageA(mProc.hWnd, WM_DESTROY, 0, 0); // 3. Destroy
EndTask(mProc.hWnd, FALSE, TRUE); // 4. EndTask
printf("\n [+] Encontrado Janelas 0x%08X de Processos de ID %4d. Terminado: ",
mProc.hWnd, mProc.dwProcId);
printf( IsWindow(mProc.hWnd) ? "Error" : "OK" ); // Kiem tra lai ket qua ?
}
}
}
}
printf("\n\nVISITE MEU WEBSITE:\n\n");
printf(" [+] http://www.skinsmuonline.com");
getch();
}

Janeiro 5, 2011

ola !!

tenho um driver.sys

estou dando load no driver virtual meu problema é como colocar umas função

dentro desse driver ex:

//para dar load no driver 
var 
 Res: boolean; 
 r: dword; 
begin 
 drPath := ExtractFilePath(paramstr(0)) + 'Driver.sys'; 
      InstallDriver(drName, PChar(drPath)); 
      LoadDriver(drName); 
      Res := OpenDriver(); 
        if Res then 
        begin 

       end else 
          begin 
            
          end; 
       end;

//função que quero dentro do driver 

function processExists(exeFileName: string): Boolean; 
var 
  ContinueLoop: BOOL; 
  FSnapshotHandle: THandle; 
  FProcessEntry32: TProcessEntry32; 
begin 
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 
  FProcessEntry32.dwSize := SizeOf(FProcessEntry32); 
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32); 
  Result := False; 
  while Integer(ContinueLoop) <> 0 do 
  begin 
    if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) = 
      UpperCase(ExeFileName)) or (UpperCase(FProcessEntry32.szExeFile) = 
      UpperCase(ExeFileName))) then 
    begin 
      Result := True; 
    end; 
    ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32); 
  end; 
  CloseHandle(FSnapshotHandle); 
end;

Dezembro 15, 2010

Ola !!

eu axei um code, e estava faltando umas paradinha e tentei corrigir

mas ainda não funciona 100% eu aperto f11 a aplicação fica em 800x600

mas quando aperto f12 não ta copiando e criando o icon da outra aplicação no systray e não da hide na aplicação.

gostaria que decem uma olhada e comentacem que ta errado.

unit minim;

interface

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

const
  IDT_RESET = (WM_USER+WM_TIMER+255);
  SC_SENDTOTRAY = -9;
  TRAYICONID = 4;
  WS_HOOKEDWINDOW = (WS_CAPTION or WS_SYSMENU);
  SWP_HOOKED = (SWP_DRAWFRAME or SWP_FRAMECHANGED or SWP_NOMOVE or SWP_NOZORDER or SWP_SHOWWINDOW);

type
  WNDDATA = record
    m_hWnd: HWND;
    m_OrigWndProc:LRESULT;
    m_niData: NOTIFYICONDATA;
    m_Subclassed: BOOL;
    m_Hidden: BOOL;
    m_Minimize: BOOL;
  end;

{<div>#pragma data_seg(".SHARE")
HHOOK g_KBHook = NULL;
WNDDATA g_Window;
BOOL g_InUse = FALSE;
BOOL g_bKeyF12 = FALSE;
BOOL g_bKeyF11 = FALSE;
INT g_XRES = 800;
INT g_YRES = 600; // default to 800 * 600
UINT SWM_TRAYMSG;
#pragma data_seg()
#pragma comment(linker,"/SECTION:.SHARE,RWS")</div> }

var
  ghModule: HINST = 0;

function IH: BOOL; cdecl;
function UIH: BOOL; cdecl;
function GetFileIconHandle(lpszFileName: LPCTSTR; bSmallIcon: BOOL): HICON;
function SubClassWindowProc(hWnd: HWND): BOOL;
function RestoreWindowProc: BOOL;
function IsMu(hWnd: HWND): BOOL;
function SCWinProc(hWnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
function KBHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
procedure TimerProc(hwnd: HWND; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
procedure SetWindowRect(hWnd: HWND);
procedure SR(Width, Height: Integer); cdecl;
function WindowValid: BOOL;

implementation



procedure MyDllProc(Reason: Integer);
var
SWM_TRAYMSG:UINT;
begin
  //Flesh out the entry point pending full implimentation

  // reserve the DLL handle
  ghModule := HInstance;

  // register system-wide message
  SWM_TRAYMSG := RegisterWindowMessage('TRAY_ACTIVATED');

  case Reason of
    DLL_PROCESS_ATTACH: begin end;
    DLL_THREAD_ATTACH: begin end;
    DLL_THREAD_DETACH: begin end;
    DLL_PROCESS_DETACH: begin end;
  end;
end;

function KBHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
var
  hWnd1: HWND;
 g_KBHook: HHOOK;
g_bKeyF12,g_bKeyF11,g_InUse: BOOL;
sDispMode: DevMode;
g_Window:WNDDATA;
HandleJan: THandle;
begin

  //Flesh out the function pending implimentation
  if nCode < 0 then
  begin
    Result := CallNextHookEx(g_KBHook, nCode, wParam, lParam);
    Exit;
  end;

  case wParam of
    VK_F11:
    begin
      if HIWORD(lParam) <> 0 then // the Key is down
      begin

        if not g_bKeyF11 then // key is not already down
        begin
          if not (g_InUse and WindowValid) then // a window is not subclassed or previous window is invalid
          begin
            // ok the hook has been requested to drop program to window
            hWnd1 := GetForegroundWindow; // get the handle for the forground window

            if IsMu(hWnd1) then
            begin
              g_InUse := SubClassWindowProc(hWnd1); // subclass the window and get its icon for its minimization

              if g_InUse then
              begin
                ChangeDisplaySettings(sDispMode,0); // drop back to windows settings
                SetWindowRect(hWnd1);
              end;

              SetTimer(hWnd1, IDT_RESET, 100, @TimerProc);


              g_bKeyF11 := True;

            end;
          end;
        end;
      end
      else begin // the key is up
        g_bKeyF11 := False;
      end;
    end;

    VK_F12:
    begin
      if HIWORD(lParam) <> 0 then // the Key is down
      begin
        if not g_Window.m_Hidden then
        begin
          g_Window.m_Hidden := True;

          Shell_NotifyIcon(NIM_ADD, @g_Window.m_niData);

          // hide window
          ShowWindow(g_Window.m_hWnd, SW_HIDE);
        end;
      end;
    end;
  end;


  Result := CallNextHookEx(g_KBHook, nCode, wParam, lParam);
end;

function SCWinProc(hWnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
var
  rct: TRect;
  pos: TPOINT;
  g_Window:WNDDATA;
  SWM_TRAYMSG:UINT;
begin
  case uMsg of
    WM_DESTROY:
    begin
      KillTimer(g_Window.m_hWnd, IDT_RESET);
      RestoreWindowProc;
    end;
    WM_SIZE, WM_ACTIVATE, WM_SETFOCUS, WM_KILLFOCUS:
    begin
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
      Exit;
      end;
    WM_CLOSE:
    begin
      KillTimer(g_Window.m_hWnd, IDT_RESET);
      RestoreWindowProc;
    end;
    WM_ACTIVATEAPP:
    begin
      if wParam <> 0 then
        SetCapture(g_Window.m_hWnd)
      else
        ReleaseCapture;
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
      Exit;
    end;
    WM_SETCURSOR, WM_NCACTIVATE:
    begin
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit;
    end;
    WM_COMMAND:
    begin
      if wParam = EN_KILLFOCUS then
      begin
        Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
        Exit;
      end;
    end;
    WM_MOUSEMOVE:
    begin
      rct  :=  Rect(0, 0, 0, 0);
      pos := POINT(0, 0, );
      GetClientRect(hWnd, rct);
      if pos.x <= rct.right then
      begin
        if pos.y <= rct.bottom then
        begin
          ShowCursor(False);
      //   Break;
        end;
      end;
      ShowCursor(True);
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
      Exit;
    end;
    WM_MOUSELEAVE:
    begin
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
      Exit;
    end;
    WM_SYSCOMMAND: // Intercept System Commands
    begin
      case wParam and $FFF0 of // Check System Calls
        SC_SCREENSAVE, // Screensaver Trying To Start?
        SC_MONITORPOWER: begin // Monitor Trying To Enter Powersave?
          Result := 0; // Prevent From Happening
          Exit;
      end;
  else
    if uMsg = SWM_TRAYMSG then
    begin
      if lParam = WM_LBUTTONDOWN then
      begin
        Shell_NotifyIcon(NIM_DELETE, @g_Window.m_niData);
        ShowWindow(g_Window.m_hWnd, SW_SHOW);
        g_Window.m_Hidden := False;
      end;
    end;
  end;

  //Flesh out the function pending implimentation
  //Result := DefWindowProc(hWnd, uMsg, wParam, lParam);
  Result := CallWindowProc(TFNWndProc(g_Window.m_OrigWndProc), hWnd, uMsg,wParam, lParam);
end;
end;
end;

function IH: BOOL; cdecl;
var
g_KBHook: HHOOK;
begin
  g_KBHook := SetWindowsHookEx(WH_KEYBOARD, KBHookProc, ghModule, 0);
  Result := (g_KBHook <> 0);
end;

function UIH: BOOL; cdecl;
var
g_InUse: BOOL;
g_KBHook: HHOOK;
begin
  if g_InUse then
    RestoreWindowProc;

  Result := UnhookWindowsHookEx(g_KBHook);
end;

function GetFileIconHandle(lpszFileName: LPCTSTR; bSmallIcon: BOOL): HICON;
var
  uFlags: UINT;
  sfi: SHFILEINFO;
begin
  uFlags := SHGFI_ICON or SHGFI_USEFILEATTRIBUTES;

  if bSmallIcon then
    uFlags := uFlags or SHGFI_SMALLICON
  else
    uFlags := uFlags or SHGFI_LARGEICON;

  SHGetFileInfo(lpszFileName, FILE_ATTRIBUTE_NORMAL, sfi, SizeOf(SHFILEINFO), uFlags);
  Result := sfi.hIcon;
end;

function SubClassWindowProc(hWnd: HWND): BOOL;
var
  szText: array[0..254] of Char;
  szPath: array[0..254] of Char;
  hIcon1: HICON;
  hModule1: HMODULE;
  g_Window:WNDDATA;
  SWM_TRAYMSG:UINT;
begin
  GetWindowText(hWnd, szText, 255);

  // prepare a NotifyData struct for this window
  ZeroMemory(@(g_Window.m_niData), SizeOf(NOTIFYICONDATA));
  g_Window.m_niData.cbSize := SizeOf(NOTIFYICONDATA);
  g_Window.m_niData.Wnd := hWnd;

  hIcon1 := HICON(SendMessage(hWnd, WM_GETICON, ICON_SMALL, 0));
  if hIcon1 <> 0 then
  begin
    hModule1 := HMODULE(OpenProcess(0, False, GetWindowThreadProcessId(hWnd)));
    GetModuleFileName(hModule1, szPath, 255);
    hIcon1 := GetFileIconHandle(szPath, True);
  end;

  if hIcon1 <0>= 0);
end;

procedure SetWindowRect(hWnd: HWND);
var
  rct: TRect;
  bHasMenu: BOOL;
  g_YRES,g_XRES:UINT;// = 800;
   g_Window:WNDDATA;
   HandleJan: THandle;
begin
  g_XRES := 800;
  g_YRES := 600;

  rct := Rect(0, 0, g_XRES, g_YRES);

  bHasMenu := True;


  SetWindowLongA(hWnd, GWL_STYLE, WS_HOOKEDWINDOW);
  SetWindowLongA(hWnd, GWL_EXSTYLE, WS_EX_OVERLAPPEDWINDOW);

  if GetMenu(g_Window.m_hWnd) = 0 then
    bHasMenu := False;

  AdjustWindowRectEx(rct, WS_HOOKEDWINDOW, bHasMenu, WS_EX_OVERLAPPEDWINDOW);
  SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, rct.right - rct.left, rct.bottom-rct.top, SWP_HOOKED);

  ShowCursor(True);
end;

procedure SR(Width, Height: Integer); cdecl;
var
g_YRES,g_XRES:UINT;
begin
  g_XRES := Width;
  g_YRES := Height;
end;

function WindowValid: BOOL;
var
  hWnd1: HWND;
  ErrorCode: DWORD;
  g_Window:WNDDATA;
begin
  hWnd1 := GetWindow(g_Window.m_hWnd, GW_HWNDFIRST); // QUICKHACK: to check if window is still valid
  ErrorCode := GetLastError;
  Result := (ErrorCode <> ERROR_INVALID_WINDOW_HANDLE);
end;

procedure TimerProc(hWnd: HWND; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
var
  rct: TRect;
  bHasMenu: BOOL;
  g_Window:WNDDATA;
  g_YRES,g_XRES:UINT;// = 800;
begin
  g_XRES := 800;
  g_YRES := 600;
  if idEvent = IDT_RESET then
  begin
    if not WindowValid then
    begin
      KillTimer(g_Window.m_hWnd, IDT_RESET);
     MessageBox(g_Window.m_hWnd, 'Timer killed', 'testando', MB_OK);
    end;

    if not g_Window.m_Hidden then
    begin
      rct := Rect(0, 0, g_XRES, g_YRES);
      bHasMenu := True;

      if GetMenu(g_Window.m_hWnd) = 0 then
        bHasMenu := False;

      AdjustWindowRectEx(rct, WS_HOOKEDWINDOW, bHasMenu, WS_EX_OVERLAPPEDWINDOW);
      SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, rct.right - rct.left, rct.bottom-rct.top, SWP_HOOKED);
     // ShowCursor(True);
    end;
  end;
end;

function IsMu(hWnd: HWND): BOOL;
var
  szText: array[0..254] of Char;
  szPath: array[0..254] of Char;
  Len: Integer;
  hModule1: HMODULE;

begin
  szText[0] := #0;
  szPath[0] := #0;

  hModule1 := HMODULE(OpenProcess(0, False, GetWindowThreadProcessId(hWnd)));
  Len := GetWindowText(hWnd, szText, 255);

  if StrIComp(szText, 'MU') <> 0 then
  begin
    Result := False;
    Exit;
  end;

  GetModuleFileName(hModule1, szPath, 255);
  CloseHandle(hModule1);

  if not AnsiSameText(ExtractFileName(szPath), 'main.exe') then
  begin

    Result := False;
    Exit;
  end;

  Result := True;
end;

exports
  IH, UIH, SR;

initialization
  DllProc := MyDllProc;
  MyDllProc(DLL_PROCESS_ATTACH);
finalization
  DllProc := nil;
end.

Novembro 27, 2010

de maneira simples seria isso, mas voce pode tentar outras opções

procedure TForm1.Button1Click(Sender: TObject);
var HandleJan: THandle;
begin
   handleJan := FindWindow('Notepad', nil);
   if HandleJan <> 0 then
      //ShowWindow(handlejan,HIDE_WINDOW); // Esconde
      SendMessage(HandleJan,WM_SYSCOMMAND, SC_MINIMIZE,0);

end;


procedure TForm1.Button2Click(Sender: TObject);
var HandleJan: THandle;
begin
   handleJan := FindWindow('Notepad', nil);
   if HandleJan <> 0 then
      ShowWindow(handlejan,SHOW_OPENWINDOW); //Mostra novamente
      //ShowWindow(handlejan,SHOW_FULLSCREEN); //Preenche toda a tela
end;

abraço

sim mas que eu realmente quero e por resolução nesse outro aplicativo que é um jogo

quando ele ta em full resolução essa função aii não minimiza

ex: handleJan := FindWindow('MU', nil); << resolução 800*600 minimize

Novembro 27, 2010

queria uma ajuda para minimizar e mudar resolução para 800*600 do outro aplicativo

estou tentando com esse code..

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls,Registry,TypInfo;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
  procedure WMHotkey(var Msg: TWMHotkey); message WM_HOTKEY;
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

const
  sw : longint = 800;
  sh : longint = 600;

procedure TForm1.WMHotkey(var Msg: TWMHotkey);
var
HandleJan: THandle;
i , w : integer;
begin
w := width; // automatico ou pode usar a constante sh
  Scaled := true;
  if (Screen.width <> sw) then
     Scaleby(screen.width,sw);
  for i := ComponentCount-1 downto 0 do
     with Components[i] do
       begin
         if GetPropInfo(ClassInfo, 'Font') <> nil then
           Font.Size := (width div w) * font.Size;

handleJan := FindWindow('Notepad', nil);
if HandleJan <> 0 then
SendMessage(HandleJan,WM_SYSCOMMAND, SC_MINIMIZE, 0);
end;
end;


{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  if not RegisterHotkey(Handle,1,0,VK_F11) then
    ShowMessage('Erro ao programar F11');

  if not RegisterHotkey(Handle, 2, MOD_CONTROL or MOD_ALT, VK_F12) then
    ShowMessage('Erro ao programar Ctrl+Alt+F12');
end;



procedure TForm1.FormDestroy(Sender: TObject);
begin
  UnRegisterHotkey(Handle, 1);
  UnRegisterHotkey(Handle, 2);
end;




procedure TForm1.Button1Click(Sender: TObject); 
var
HandleJan: THandle;
Registry: TRegistry;
begin
handleJan := FindWindow('Notepad', nil);
if HandleJan <> 0 then
SendMessage(HandleJan, WM_SYSCOMMAND, SC_Restore, 0);
end;


end.

ele minimiza outro aplicativo mas não muda a resolução do outro aplicativo e sim o meu :(

Novembro 25, 2010

amigo , esse código é uma conversão de uma dll em C++ para delphi
https://forums.embarcadero.com/thread.jspa?messageID=181022
então voce vai em File > New > Unit
e cole esse código nessa unit, salve e depois utilize-a como uma chamada em seu aplicativo
OBS:
O comando compile pode ser usado somente quando você tiver carregado um projeto no editor.
Se nenhum projeto estiver ativo e você carregar um arquivo-fonte Pascal ( como essa unit ) , não poderá compilá-lo.
Porém se você carregar o arquivo-fonte como se ele fosse um projeto, poderá compila-lo
Se houver algum erro no código, durante a execução o erro será informado
abraço

amigo é que ta mal convertida, ta com muitos errinhos

você poderia ajudar corrigir

ex:

type

WNDDATA = record

m_hWnd: HWND;

m_OrigWndProc LRESULT; << falta :

m_niData: NOTIFYICONDATA;

m_Subclassed: BOOL;

m_Hidden: BOOL;

end;

e otras coisinhas

Novembro 25, 2010

unit HookDLL; 
  
interface 
  
uses 
  Windows; 
  
const 
  IDT_RESET = (WM_USER+WM_TIMER+0xff); 
  SC_SENDTOTRAY = -90; 
  TRAYICONID = 4; 
  WS_HOOKEDWINDOW = (WS_CAPTION or WS_SYSMENU); 
  SWP_HOOKED = (SWP_DRAWFRAME or SWP_FRAMECHANGED or SWP_NOMOVE or SWP_NOZORDER or SWP_SHOWWINDOW); 
  
type 
  WNDDATA = record 
    m_hWnd: HWND; 
    m_OrigWndProc LRESULT; 
    m_niData: NOTIFYICONDATA; 
    m_Subclassed: BOOL; 
    m_Hidden: BOOL; 
  end; 
  
<div>#pragma data_seg(".SHARE") 
HHOOK g_KBHook = NULL; 
WNDDATA g_Window; 
BOOL g_InUse = FALSE; 
BOOL g_bKeyF12 = FALSE; 
BOOL g_bKeyF11 = FALSE; 
INT g_XRES = 800; 
INT g_YRES = 600; // default to 800 * 600 
UINT SWM_TRAYMSG; 
#pragma data_seg() 
#pragma comment(linker,"/SECTION:.SHARE,RWS")</div> 
  
var 
  ghModule: HINSTANCE = 0; 
  
function IH: BOOL; cdecl; 
function UIH: BOOL; cdecl; 
function GetFileIconHandle(lpszFileName: LPCTSTR; bSmallIcon: BOOL): HICON; 
function SubClassWindowProc(hWnd: HWND): BOOL; 
function RestoreWindowProc: BOOL; 
function IsMu(hWnd: HWND): BOOL; 
function SCWinProc(hWnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; 
function KBHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; 
procedure TimerProc(hwnd: HWND; uMsg: UINT; idEvent: UINT_PTR; dwTime: DWORD); stdcall; 
procedure SetWindowRect(hWnd: HWND); 
procedure SR(Width, Height: Integer); cdecl; 
function WindowValid: BOOL; 
  
implemenation 
  
uses 
  ShellApi, SysUtils; 
  
procedure MyDllProc(Reason: Integer); 
begin 
  //Flesh out the entry point pending full implimentation 
  
  // reserve the DLL handle 
  ghModule = HInstance; 
  
  // register system-wide message 
  SWM_TRAYMSG := RegisterWindowMessage('TRAY_ACTIVATED'); 
  
  case Reason of 
    DLL_PROCESS_ATTACH: begin end; 
    DLL_THREAD_ATTACH: begin end; 
    DLL_THREAD_DETACH: begin end; 
    DLL_PROCESS_DETACH: begin end; 
  end; 
end; 
  
function KBHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; 
var 
  hWnd: HWND; 
begin 
  //Flesh out the function pending implimentation 
  if nCode < 0 then 
  begin 
    Result := CallNextHookEx(g_KBHook, nCode, wParam, lParam); 
    Exit; 
  end; 
  
  case wParam of 
    VK_F11: 
    begin 
      if HIWORD(lParam) <> 0 then // the Key is down 
      begin 
        if not g_bKeyF11 then // key is not already down 
        begin 
          if not (g_InUse and WindowValid) then // a window is not subclassed or previous window is invalid 
          begin 
            // ok the hook has been requested to drop program to window 
            hWnd := GetForegroundWindow; // get the handle for the forground window 
  
            if IsMu(hWnd) then 
            begin 
              g_InUse := SubClassWindowProc(hWnd); // subclass the window and get its icon for its minimization 
  
              if g_InUse then 
              begin 
                ChangeDisplaySettings(nil, 0); // drop back to windows settings 
                SetWindowRect(hWnd); 
              end; 
  
              SetTimer(hWnd, IDT_RESET, 100, TimerProc); 
  
              g_bKeyF11 := True; 
            end; 
          end; 
        end; 
      end 
      else begin // the key is up 
        g_bKeyF11 := False; 
      end; 
    end; 
  
    VK_F12: 
    begin 
      if HIWORD(lParam) <> 0 then // the Key is down 
      begin 
        if not g_Window.m_Hidden then 
        begin 
          g_Window.m_Hidden := True; 
          Shell_NotifyIcon(NIM_ADD, @g_Window.m_niData); 
  
          // hide window 
          ShowWindow(g_Window.m_hWnd, SW_HIDE); 
        end; 
      end; 
    end; 
  end; 
  
  Result := CallNextHookEx(g_KBHook, nCode, wParam, lParam); 
end; 
  
function SCWinProc(hWnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall; 
var 
  rct: TRect; 
  pos: POINTS; 
begin 
  case uMsg of 
    WM_DESTROY: 
    begin 
      KillTimer(g_Window.m_hWnd, IDT_RESET); 
      RestoreWindowProc; 
    end; 
    WM_SIZE, WM_ACTIVATE, WM_SETFOCUS, WM_KILLFOCUS: 
    begin 
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit; 
    WM_CLOSE: 
    begin 
      KillTimer(g_Window.m_hWnd, IDT_RESET); 
      RestoreWindowProc; 
    end; 
    WM_ACTIVATEAPP: 
    begin 
      if wParam <> 0 then 
        SetCapture(g_Window.m_hWnd) 
      else 
        ReleaseCapture; 
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit; 
    end; 
    WM_SETCURSOR, WM_NCACTIVATE: 
    begin 
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit; 
    end; 
    WM_COMMAND: 
    begin 
      if wParam = EN_KILLFOCUS then 
      begin 
        Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
        Exit; 
      end; 
    end; 
    WM_MOUSEMOVE: 
    begin 
      rct  =  Rect(0, 0, 0, 0); 
      pos := MAKEPOINTS(lParam); 
      GetClientRect(hWnd, rct); 
      if pos.x <= rct.right then 
      begin 
        if pos.y <= rct.bottom then 
        begin 
          ShowCursor(False); 
          Break; 
        end; 
      end; 
      ShowCursor(True); 
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit; 
    end; 
    WM_MOUSELEAVE: 
    begin 
      Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
      Exit; 
    end; 
    WM_SYSCOMMAND: // Intercept System Commands 
    begin 
      case wParam and $FFF0 of // Check System Calls 
        SC_SCREENSAVE, // Screensaver Trying To Start? 
        SC_MONITORPOWER: begin // Monitor Trying To Enter Powersave? 
          Result := 0; // Prevent From Happening 
          Exit; 
      end; 
    end; 
  else 
    if uMsg = SWM_TRAYMSG then 
    begin 
      if lParam = WM_LBUTTONDOWN then 
      begin 
        Shell_NotifyIcon(NIM_DELETE, @g_Window.m_niData); 
        ShowWindow(g_Window.m_hWnd, SW_SHOW); 
        g_Window.m_Hidden := False; 
      end; 
    end; 
  end; 
  
  //Flesh out the function pending implimentation 
  //Result := DefWindowProc(hWnd, uMsg, wParam, lParam); 
  Result := CallWindowProc(TFNWndProc(g_Window.m_OrigWndProc), hWnd, uMsg,wParam, lParam); 
end; 
  
function IH: BOOL; cdecl; 
begin 
  g_KBHook := SetWindowsHookEx(WH_KEYBOARD, KBHookProc, ghModule, 0); 
  Result := (g_KBHook <> nil); 
end; 
  
function UIH: BOOL; cdecl; 
begin 
  if g_InUse then 
    RestoreWindowProc; 
  
  Result := UnhookWindowsHookEx(g_KBHook); 
end; 
  
function GetFileIconHandle(lpszFileName: LPCTSTR; bSmallIcon: BOOL): HICON; 
var 
  uFlags: UINT; 
  sfi: SHFILEINFO; 
begin 
  uFlags := SHGFI_ICON or SHGFI_USEFILEATTRIBUTES; 
  
  if bSmallIcon then 
    uFlags := uFlags or SHGFI_SMALLICON 
  else 
    uFlags := uFlags or SHGFI_LARGEICON; 
  
  SHGetFileInfo(lpszFileName, FILE_ATTRIBUTE_NORMAL, @sfi, SizeOf(SHFILEINFO), uFlags); 
  Result := sfi.hIcon; 
end; 
  
function SubClassWindowProc(hWnd: HWND): BOOL; 
var 
  szText: array[0..254] of Char; 
  szPath: array[0..254] of Char; 
  hIcon: HICON; 
  hModule: HMODULE; 
begin 
  GetWindowText(hWnd, szText, 255); 
  
  // prepare a NotifyData struct for this window 
  ZeroMemory(@(g_Window.m_niData), SizeOf(NOTIFYICONDATA)); 
  g_Window.m_niData.cbSize := SizeOf(NOTIFYICONDATA); 
  g_Window.m_niData.hWnd := hWnd; 
  
  hIcon := HICON(SendMessage(hWnd, WM_GETICON, ICON_SMALL, 0)); 
  if hIcon <> 0 then 
  begin 
    hModule := HMODULE(OpenProcess(0, False, GetWindowThreadProcessId(hWnd, 0))); 
    GetModuleFileName(hModule, szPath, 255); 
    hIcon := GetFileIconHandle(szPath, True); 
  end; 
  
  if hIcon <0>= 0); 
end; 
  
procedure SetWindowRect(hWnd: HWND); 
var 
  rct: TRect; 
  bHasMenu: BOOL; 
begin 
  rct = Rect(0, 0, g_XRES, g_YRES); 
  bHasMenu := True; 
  
  SetWindowLongPtr(hWnd, GWL_STYLE, WS_HOOKEDWINDOW); 
  SetWindowLongPtr(hWnd, GWL_EXSTYLE, WS_EX_OVERLAPPEDWINDOW); 
  
  if GetMenu(g_Window.m_hWnd) = 0 then 
    bHasMenu := False; 
  
  AdjustWindowRectEx(rct, WS_HOOKEDWINDOW, bHasMenu, WS_EX_OVERLAPPEDWINDOW); 
  SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, rct.right - rct.left, rct.bottom-rct.top, SWP_HOOKED); 
  
  ShowCursor(True); 
end; 
  
procedure SR(Width, Height: Integer); cdecl; 
begin 
  g_XRES := Width; 
  g_YRES := Height; 
end; 
  
function WindowValid: BOOL; 
var 
  hWnd: HWND; 
  ErrorCode: DWORD; 
begin 
  hWnd := GetWindow(g_Window.m_hWnd, GW_HWNDFIRST); // QUICKHACK: to check if window is still valid 
  ErrorCode := GetLastError; 
  Result := (ErrorCode <> ERROR_INVALID_WINDOW_HANDLE); 
end; 
  
procedure TimerProc(hWnd: HWND; uMsg: UINT; idEvent: UINT_PTR; dwTime: DWORD); stdcall; 
var 
  rct: TRect; 
  bHasMenu: BOOL; 
begin 
  if idEvent = IDT_RESET then 
  begin 
    if not WindowValid then 
    begin 
      KillTimer(g_Window.m_hWnd, IDT_RESET); 
      MessageBox(g_Window.m_hWnd, 'Timer killed', 'TIMER', MB_OK); 
    end; 
  
    if not g_Window.m_Hidden then 
    begin 
      rct = Rect(0, 0, g_XRES, g_YRES); 
      bHasMenu := True; 
  
      if GetMenu(g_Window.m_hWnd) = 0 then 
        bHasMenu := False; 
  
      AdjustWindowRectEx(rct, WS_HOOKEDWINDOW, bHasMenu, WS_EX_OVERLAPPEDWINDOW); 
      SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, rct.right - rct.left, rct.bottom-rct.top, SWP_HOOKED); 
      //ShowCursor(True); 
    end; 
  end; 
end; 
  
function IsMu(hWnd: HWND): BOOL; 
var 
  szText: array[0..254] of Char; 
  szPath: array[0..254] of Char; 
  Len: Integer; 
  hModule: HMODULE; 
begin 
  szText[0] := #0; 
  szPath[0] := #0; 
  
  hModule := HMODULE(OpenProcess(0, False, GetWindowThreadProcessId(hWnd, 0))); 
  Len := GetWindowText(hWnd, szText, 255); 
  
  if StrIComp(szText, 'mu') <> 0 then 
  begin 
    Result := False; 
    Exit; 
  end; 
  
  GetModuleFileName(hModule, szPath, 255); 
  CloseHandle(hModule); 
  
  if not AnsiSameText(ExtractFileName(szPath), 'main.exe') then 
  begin 
    Result := False; 
    Exit; 
  end; 
  
  Result := True; 
end; 
  
exports 
  IH, UIH, SR; 
  
initialization 
  DllProc := MyDllProc; 
  MyDllProc(DLL_PROCESS_ATTACH.); 
finalization 
  DllProc := nil; 
end.

Novembro 25, 2010

Ola!!

Ajuda Converter esse code para delphi7

// HookDLL.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "HookDLL.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{
    //Flesh out the entry point pending full implimentation

    // reserve the DLL handle
    ghModule = (HINSTANCE)hModule;

    // register system-wide message
    SWM_TRAYMSG = RegisterWindowMessage("TRAY_ACTIVATED"); // will be used when sending window to tray

    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

LRESULT CALLBACK KBHookProc(int nCode,WPARAM wParam,LPARAM lParam)
{
    //Flesh out the function pending implimentation
    if(nCode < 0) {
        return CallNextHookEx(g_KBHook,nCode,wParam,lParam);
    }

    switch(wParam)
    {
        case VK_F11:
            if(HIWORD(lParam)){ // the Key is down
                
                if(g_bKeyF11) // key is already down
                    break;
            
                if(g_InUse) // a window is already subclassed
                {
                    if(WindowValid()) // check if previous window is still valid
                        break;
                }
                                            
                // ok the hook has been requested to drop program to window

                HWND hWnd = GetForegroundWindow(); // get the handle for the forground window
                
                if(!IsMu(hWnd))
                    break;

                g_InUse = SubClassWindowProc(hWnd); // subclass the window and get its icon for its minimization

                if(g_InUse)
                {
                    ChangeDisplaySettings(NULL,0); // drop back to windows settings
                
                    SetWindowRect(hWnd);
                }

                SetTimer(hWnd, IDT_RESET,100,TimerProc); 

                g_bKeyF11 = TRUE;
            }
            else { // the key is up
                g_bKeyF11 = FALSE;
            }
        break;
        case VK_F12:
            if(HIWORD(lParam)){ // the Key is down
                
                if(!g_Window.m_Hidden)
                {
                    g_Window.m_Hidden = TRUE;
                    Shell_NotifyIcon(NIM_ADD, &g_Window.m_niData);
    
                    // hide window
                    ShowWindow(g_Window.m_hWnd, SW_HIDE);
                }
            }
        break;
    }

    return CallNextHookEx(g_KBHook, nCode, wParam, lParam);
}

LRESULT CALLBACK SCWinProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{

    switch(uMsg)
    {
        case WM_DESTROY:
                KillTimer(g_Window.m_hWnd,IDT_RESET);
                RestoreWindowProc();
        break;
        case WM_SIZE:
        case WM_ACTIVATE:
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            return DefWindowProc(hWnd,uMsg,wParam,lParam);
        break;
        case WM_CLOSE:
                KillTimer(g_Window.m_hWnd,IDT_RESET);
                RestoreWindowProc();
        break;
        case WM_ACTIVATEAPP:
            if((BOOL)wParam)
                SetCapture(g_Window.m_hWnd);
            else
                ReleaseCapture();
            return DefWindowProc(hWnd,uMsg,wParam,lParam);
        break;
        case WM_SETCURSOR:
        case WM_NCACTIVATE:
            return DefWindowProc( hWnd, uMsg, wParam, lParam );
        break;
        case WM_COMMAND:
            if(wParam == EN_KILLFOCUS)
                return DefWindowProc( hWnd, uMsg, wParam, lParam );
        break;
        case WM_MOUSEMOVE:
        {
            RECT rct =  { 0,0,0,0 };
            POINTS pos = MAKEPOINTS(lParam);
            GetClientRect(hWnd,&rct);
            if(pos.x <= rct.right)
            {
                if(pos.y <= rct.bottom)
                {    
                    ShowCursor(FALSE);
                    break;
                }
            }
            ShowCursor(TRUE);
            return DefWindowProc(hWnd,uMsg,wParam,lParam);
        }
        case WM_MOUSELEAVE:
            return DefWindowProc(hWnd,uMsg,wParam,lParam);
        break;
        case WM_SYSCOMMAND:                                                // Intercept System Commands
        {
            switch (wParam)                                                // Check System Calls
            {
                case SC_SCREENSAVE:                                        // Screensaver Trying To Start?
                case SC_MONITORPOWER:                                    // Monitor Trying To Enter Powersave?
                return 0;                                                // Prevent From Happening
            }
            break;                                                        // Exit
        }
        default:
            if(uMsg == SWM_TRAYMSG)
            {
                if(lParam == WM_LBUTTONDOWN)
                {
                    Shell_NotifyIcon(NIM_DELETE, &g_Window.m_niData);
                    ShowWindow(g_Window.m_hWnd, SW_SHOW);
                    g_Window.m_Hidden = FALSE;
                }
            }
        break;
    }
/*        switch(uMsg)
        {
        case WM_DESTROY:
        case WM_CLOSE:
                return CallWindowProc((WNDPROC)g_Window.m_OrigWndProc,hWnd,uMsg,wParam,lParam);
        break;
        case WM_COMMAND:
            if(wParam != EN_KILLFOCUS)
                return CallWindowProc((WNDPROC)g_Window.m_OrigWndProc,hWnd,uMsg,wParam,lParam);
        break;
        case WM_MOUSEMOVE:
        {
            RECT rct =  { 0,0,0,0 };
            POINTS pos = MAKEPOINTS(lParam);
            GetWindowRect(hWnd,&rct);
            if(pos.x <= rct.right)
                if(pos.y <= rct.bottom)
                    return CallWindowProc((WNDPROC)g_Window.m_OrigWndProc,hWnd,uMsg,wParam,lParam);
        break;
        }
        default:
            if(uMsg == SWM_TRAYMSG)
            {
                if(lParam == WM_LBUTTONDOWN)
                {
                    Shell_NotifyIcon(NIM_DELETE, &g_Window.m_niData);
                    ShowWindow(g_Window.m_hWnd, SW_SHOW);
                    g_Window.m_Hidden = FALSE;
                }
            }
        break;
    }*/

    //Flesh out the function pending implimentation
    //return DefWindowProc(hWnd,uMsg,wParam,lParam);
    return CallWindowProc((WNDPROC)g_Window.m_OrigWndProc,hWnd,uMsg,wParam,lParam);
}

HOOKDLL_API BOOL IH()
{
    g_KBHook = SetWindowsHookEx(WH_KEYBOARD, KBHookProc, ghModule, 0);
    
    if( g_KBHook == NULL ){
        return FALSE;    
    }

    return TRUE;
}

HOOKDLL_API BOOL UIH()
{
    if(g_InUse)
        RestoreWindowProc();

    return UnhookWindowsHookEx(g_KBHook);
}

HICON GetFileIconHandle(LPCTSTR lpszFileName, BOOL bSmallIcon)
{
    UINT uFlags = SHGFI_ICON | SHGFI_USEFILEATTRIBUTES;

    if (bSmallIcon)
        uFlags |= SHGFI_SMALLICON;
    else
        uFlags |= SHGFI_LARGEICON;

    SHFILEINFO sfi;
    SHGetFileInfo(lpszFileName, FILE_ATTRIBUTE_NORMAL, &sfi, sizeof(SHFILEINFO), uFlags);

    return sfi.hIcon;
}

BOOL SubClassWindowProc(HWND hWnd)
{
    char szText[255];
    GetWindowText(hWnd, szText, 255);
                                            
    // prepare a NotifyData struct for this window
    ZeroMemory(&(g_Window.m_niData), sizeof(NOTIFYICONDATA));
    g_Window.m_niData.cbSize = sizeof(NOTIFYICONDATA);
    g_Window.m_niData.hWnd = hWnd;
                
    HICON hIcon = (HICON)SendMessage(hWnd, WM_GETICON, ICON_SMALL,0);                    
    
    if(!hIcon){
        char szPath[255];
        HMODULE hModule = (HMODULE)OpenProcess(0, FALSE, GetWindowThreadProcessId(hWnd, 0));
        GetModuleFileName(hModule, szPath, 255);
        hIcon = GetFileIconHandle(szPath, TRUE);
    }
                        
                        
    if(hIcon){
        g_Window.m_niData.hIcon = CopyIcon(hIcon);
    }
    else{
        g_Window.m_niData.hIcon = LoadIcon(NULL, IDI_QUESTION);
    }
    
    g_Window.m_niData.uID = TRAYICONID;
    g_Window.m_niData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
    strcpy(g_Window.m_niData.szTip, szText);
    
    
    g_Window.m_niData.uCallbackMessage = SWM_TRAYMSG;

    g_Window.m_hWnd = hWnd;
    g_Window.m_Hidden = FALSE;
    g_Window.m_OrigWndProc = GetWindowLongPtr(hWnd,GWL_WNDPROC);
    
    if(SetWindowLongPtr(hWnd,GWL_WNDPROC,(LONG)SCWinProc) == g_Window.m_OrigWndProc)
        g_Window.m_Subclassed = TRUE;
    else
        g_Window.m_Subclassed = FALSE;

    return g_Window.m_Subclassed;
}

BOOL RestoreWindowProc()
{

    g_Window.m_Subclassed = FALSE;
    g_Window.m_Hidden = FALSE;
    Shell_NotifyIcon(NIM_DELETE, &g_Window.m_niData);
    ShowWindow(g_Window.m_hWnd, SW_SHOW);
    g_Window.m_Hidden = FALSE;
    g_InUse = FALSE;

    return ( SetWindowLongPtr(g_Window.m_hWnd,GWL_WNDPROC,(LONG)g_Window.m_OrigWndProc) >= 0);
}

VOID SetWindowRect(HWND hWnd)
{    
    RECT rct = { 0,0 ,g_XRES,g_YRES };
    BOOL bHasMenu = TRUE;

    SetWindowLongPtr(hWnd,GWL_STYLE,(LONG)WS_HOOKEDWINDOW);
    SetWindowLongPtr(hWnd,GWL_EXSTYLE,(LONG)WS_EX_OVERLAPPEDWINDOW);

    if(GetMenu(g_Window.m_hWnd) == NULL)
        bHasMenu = FALSE;

    AdjustWindowRectEx(&rct,WS_HOOKEDWINDOW,bHasMenu,WS_EX_OVERLAPPEDWINDOW);
    SetWindowPos(hWnd,HWND_NOTOPMOST,0,0,rct.right - rct.left,rct.bottom-rct.top,SWP_HOOKED);

    ShowCursor(TRUE);
}

HOOKDLL_API VOID SR(INT Width,INT Height)
{
    g_XRES = Width;
    g_YRES = Height;
}

BOOL WindowValid()
{
    HWND hWnd = GetWindow(g_Window.m_hWnd,GW_HWNDFIRST); // QUICKHACK: to check if window is still valid

    DWORD ErrorCode = GetLastError();

    if(ErrorCode == ERROR_INVALID_WINDOW_HANDLE)
        return FALSE;

    return TRUE;
}

VOID CALLBACK TimerProc( HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
    if(idEvent == IDT_RESET)
    {
        if(!WindowValid())
        {
            KillTimer(g_Window.m_hWnd,IDT_RESET);
            MessageBox(g_Window.m_hWnd,"Timer killed","TIMER",MB_OK);
        }

        if(!g_Window.m_Hidden)
        {
            RECT rct = { 0,0, g_XRES,g_YRES };
            BOOL bHasMenu = TRUE;

            if(GetMenu(g_Window.m_hWnd) == NULL)
                bHasMenu = FALSE;

            AdjustWindowRectEx(&rct,WS_HOOKEDWINDOW,bHasMenu,WS_EX_OVERLAPPEDWINDOW);
            SetWindowPos(hWnd,HWND_NOTOPMOST,0,0,rct.right - rct.left,rct.bottom-rct.top,SWP_HOOKED);
            //ShowCursor(TRUE);
        }
    }
}

BOOL IsMu(HWND hWnd)
{
    char szText[255]="";
    char szPath[255]="";
    char szTokS[] = "\\/";
    char *szTokC = NULL;
    char szTokO[255]="";
    int Len = 0;

    HMODULE hModule = (HMODULE)OpenProcess(0, FALSE, GetWindowThreadProcessId(hWnd, 0));
    
    Len = GetWindowText(hWnd, szText, 255);

    if(strcmp(strlwr(szText),"mu") != 0 )
        return FALSE;
    
    GetModuleFileName(hModule, szPath, 255);
    CloseHandle(hModule);

    szTokC = strtok(szPath,szTokS);    

    while(szTokC != NULL)
    {
        strcpy(szTokO,szTokC);

        szTokC = strtok(NULL,szTokS);
    }

    if(strcmp(strlwr(szTokO),"main.exe") != 0)
        return FALSE;

    return TRUE;
}

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the HOOKDLL_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// HOOKDLL_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef HOOKDLL_EXPORTS // dont decorate the exports
#define HOOKDLL_API extern "C" __declspec(dllexport)
#else
#define HOOKDLL_API extern "C" __declspec(dllimport)
#endif

#define IDT_RESET        (WM_USER+WM_TIMER+0xff)
#define SC_SENDTOTRAY    (-90)
#define TRAYICONID    4
#define WS_HOOKEDWINDOW        (WS_CAPTION        | \
                             WS_SYSMENU)

#define SWP_HOOKED            (SWP_DRAWFRAME        | \
                             SWP_FRAMECHANGED    | \
                             SWP_NOMOVE            | \
                             SWP_NOZORDER        | \
                             SWP_SHOWWINDOW)


struct WNDDATA{
    HWND            m_hWnd;
    LRESULT            m_OrigWndProc;
    NOTIFYICONDATA    m_niData;
    BOOL            m_Subclassed;
    BOOL            m_Hidden;
};

#pragma data_seg(".SHARE")
    HHOOK            g_KBHook = NULL;
    WNDDATA            g_Window;
    BOOL            g_InUse = FALSE;
    BOOL            g_bKeyF12 = FALSE;
    BOOL            g_bKeyF11 = FALSE;
    INT                g_XRES = 800;
    INT                g_YRES = 600; // default to 800 * 600
    UINT            SWM_TRAYMSG;
#pragma data_seg()
#pragma comment(linker,"/SECTION:.SHARE,RWS")

HINSTANCE    ghModule    = NULL;

HOOKDLL_API BOOL IH();
HOOKDLL_API BOOL UIH();
HICON GetFileIconHandle(LPCTSTR lpszFileName, BOOL bSmallIcon);
BOOL SubClassWindowProc(HWND hWnd);
BOOL RestoreWindowProc();
BOOL IsMu(HWND hWnd);
LRESULT CALLBACK SCWinProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam); // subclassed window proc
LRESULT CALLBACK KBHookProc(INT nCode,WPARAM wParam,LPARAM lParam); // the KeyBoard proc
VOID CALLBACK TimerProc( HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);
VOID SetWindowRect(HWND hWnd);
HOOKDLL_API VOID SR(INT Width,INT Height);
BOOL WindowValid();

Entrar

Francis carlos

Total de itens

Registro em

Última visita

Tipo de Conteúdo

Perfis

Fóruns

Posts postados por Francis carlos

Converter Codigo c+ para delphi

Converter Codigo c+ para delphi

Converter code c++ para delphi7

Ajuda com Função Driver.sys

code Unit minimiza outra aplicação

Mudar resolução e Minimimizar outro aplicativo

Mudar resolução e Minimimizar outro aplicativo

Code não copila ajuda corrigir erro

Code não copila ajuda corrigir erro

Converter C++ Para Delphi7

Navegação

Atividades