How to perfect this code

//begin DPR
program Project1;
uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1},
  FPipes in 'FPipes.pas';

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.
//end DPR




//begin UNIT1
unit Unit1;
interface
uses Fpipes,
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;
type
  TForm1 = class(TForm)
    Button2: TButton;
    Button1: TButton;
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
     FServer: TPipeServer;
     procedure OnPipeData(Sender: TObject; aData: String; var aRespond: String);

  public
    { Public declarations }
    
  end;

var
  Form1: TForm1;
  //HookMsg: cardinal;

function SetHook(): Boolean; stdcall; external 'MatHook.dll';
function RemoveHook(): Boolean; stdcall; external 'MatHook.dll';

implementation

{$R *.dfm}

procedure TForm1.OnPipeData(Sender: TObject; aData: String; var aRespond: String);
begin
Form1.Text := aData;
//showmessage(aData);
//respond //test only
aRespond := '0';
end;


procedure TForm1.Button2Click(Sender: TObject);
begin
if (not RemoveHook) then ShowMessage('Couldn''t stop Hook');
FServer.Free;
Form1.Text := '';
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
if (not SetHook) then ShowMessage('Couldn''t start Hook');
FServer := TPipeServer.CreatePipeServer('', 'TwinSoft', True);
FServer.OnData := OnPipeData;
end;

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
if (not RemoveHook) then ShowMessage('Couldn''t stop Hook');
FServer.Free;
Form1.Text := '';
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
if (not SetHook) then ShowMessage('Couldn''t start Hook');
FServer := TPipeServer.CreatePipeServer('', 'TwinSoft', True);
FServer.OnData := OnPipeData;
end;


//initialization
//HookMsg := RegisterWindowMessage('myhookdll_hookmsg');

end.
//end UNIT1





//begin unit FPIPES
unit FPipes;

interface

uses
  Classes, Windows;

const
  cShutDownMsg = 'shutdown';
  cPipeFormat = '\\%s\pipe\%s';

type
  RPIPEMessage = record
    Size: DWORD;
    Kind: Byte;
    Count: DWORD;
    Data: array[0..8095] of Char;
  end;

  TOnDataEvent = procedure(Sender: TObject; aData: String; var aRespond: String) of Object;

  TPipeServer = class(TThread)
  private
    FHandle: THandle;
    FPipeName: string;
    FOnData: TOnDataEvent;
  protected
  public
    constructor CreatePipeServer(aServer, aPipe: string; StartServer: Boolean);
    destructor Destroy; override;
    procedure StartUpServer;
    procedure ShutDownServer;
    procedure Execute; override;
    property OnData: TOnDataEvent read FOnData write FOnData;
  end;

  TPipeClient = class
  private
    FPipeName: string;
    function ProcessMsg(aMsg: RPIPEMessage): RPIPEMessage;
  protected
  public
    constructor Create(aServer, aPipe: string);
    function SendString(aStr: string): string;
  end;

implementation

uses
  SysUtils;

procedure CalcMsgSize(var Msg: RPIPEMessage);
begin
 Msg.Size := SizeOf(Msg.Size) +
             SizeOf(Msg.Kind) +
             SizeOf(Msg.Count) +
             Msg.Count + 3;
end;

{ TPipeServer }

constructor TPipeServer.CreatePipeServer(aServer, aPipe: string; StartServer: Boolean);
begin
 if aServer = '' then
  FPipeName := Format(cPipeFormat, ['.', aPipe])
 else
  FPipeName := Format(cPipeFormat, [aServer, aPipe]);
 FHandle := INVALID_HANDLE_VALUE;
 if StartServer then
  StartUpServer;
 Create(not StartServer);
end;

destructor TPipeServer.Destroy;
begin
 if FHandle <> INVALID_HANDLE_VALUE then
  ShutDownServer;
 inherited Destroy;
end;

procedure TPipeServer.Execute;
var
 i, w: Cardinal;
 InMsg,
 OutMsg: RPIPEMessage;
 s, r: String;
begin
 while not Terminated do
  begin
   if (FHandle = INVALID_HANDLE_VALUE) then
    Sleep(250)
   else
    if ConnectNamedPipe(FHandle, nil) then
     try
      InMsg.Size := SizeOf(InMsg);
      ReadFile(FHandle, InMsg, InMsg.Size, InMsg.Size, nil);
      if not Terminated and Assigned(FOnData) then
       begin
        s := '';
        for i := 0 to Pred(InMsg.Count) do
         s := s + InMsg.Data[i];
        FOnData(Self, s, r);
        OutMsg.Kind := 0;
        OutMsg.Count := Length(r);
        StrPCopy(OutMsg.Data, r);
        CalcMsgSize(OutMsg);
        WriteFile(FHandle, OutMsg, OutMsg.Size, w, nil);
       end;
     finally
      DisconnectNamedPipe(FHandle);
     end;
  end;
end;

procedure TPipeServer.ShutDownServer;
var
 InMsg,
 OutMsg: RPIPEMessage;
 BytesRead: Cardinal;
begin
 if FHandle <> INVALID_HANDLE_VALUE then
  begin
   Terminate;
   OutMsg.Size := SizeOf(OutMsg);
   with InMsg do
    begin
     Kind := 0;
     Count := Length(cShutDownMsg);
     StrPCopy(Data, cShutDownMsg);
    end;
   CalcMsgSize(InMsg);
   CallNamedPipe(PChar(FPipeName), @InMsg, InMsg.Size, @OutMsg, OutMsg.Size, BytesRead, 100);
   CloseHandle(FHandle);
   FHandle := INVALID_HANDLE_VALUE;
  end;
end;

procedure TPipeServer.StartUpServer;
begin
 if WaitNamedPipe(PChar(FPipeName), 100 {ms}) then
  raise Exception.Create('Requested PIPE exists already.');

 FHandle := CreateNamedPipe(PChar(FPipeName), PIPE_ACCESS_DUPLEX,
                            PIPE_TYPE_MESSAGE or PIPE_READMODE_MESSAGE or PIPE_WAIT,
                            PIPE_UNLIMITED_INSTANCES, SizeOf(RPIPEMessage), SizeOf(RPIPEMessage),
                            NMPWAIT_USE_DEFAULT_WAIT, nil);

 if FHandle = INVALID_HANDLE_VALUE then
  raise Exception.Create('Could not create PIPE.');
end;

{ TPipeClient }

constructor TPipeClient.Create(aServer, aPipe: string);
begin
 inherited Create;
 if aServer = '' then
  FPipeName := Format(cPipeFormat, ['.', aPipe])
 else
  FPipeName := Format(cPipeFormat, [aServer, aPipe]);
end;

function TPipeClient.ProcessMsg(aMsg: RPIPEMessage): RPIPEMessage;
begin
 CalcMsgSize(aMsg);
 Result.Size := SizeOf(Result);
 if WaitNamedPipe(PChar(FPipeName), 10) then
  if not CallNamedPipe(PChar(FPipeName), @aMsg, aMsg.Size, @Result, Result.Size, Result.Size, 500) then
   raise Exception.Create('PIPE did not respond.')
  else
 else
  raise Exception.Create('PIPE does not exist.');
end;

function TPipeClient.SendString(aStr: string): string;
var
 Msg: RPIPEMessage;
begin
 Msg.Kind := 1;
 Msg.Count := Length(aStr);
 StrPCopy(Msg.Data, aStr);
 Msg := ProcessMsg(Msg);
 Result := Copy(Msg.Data, 1, Msg.Count);
end;

end.
//end unit FPIPES




//begin DLL
library MatHook;

uses
  Windows,
  Messages,
  Fpipes;

type
  THookRec = record
    hMatHook: HHOOK;
    hMatWnd: HWND;
    oldProc: Integer;
  end;

var
  map: DWord;
  buf: ^THookRec;

// new window proc - runs in context of target process
function MatWndProc(Handle: hWnd; Msg: uInt; wp: wParam; lp: lParam): LongInt; stdcall;
var aResult:string;
begin
  try
    case Msg of
      WM_CREATE:
      begin
        //MessageBox(0, GetCommandLine, 'Command Line parameter(s)', MB_OK);

 with TPipeClient.Create('', 'TwinSoft') do
  try
   aResult := SendString(GetCommandLine);
  finally
   Free;
  end;


if aResult = '1' then
begin
Result := CallWindowProc(Pointer(buf^.oldProc), Handle, Msg, wp, lp);
MessageBox(0, GetCommandLine, 'THIS WILL CONTINUE LAUNCHING', MB_OK);
end
else
begin
result := 1;
MessageBox(0, GetCommandLine, 'THIS WILL NOT CONTINUE TO OPEN', MB_OK);
end;


      end;

      // user definied message to stop subclassing
      // (RegisterWindowMessage would be a better choice instead of WM_USER message!)
      WM_USER + 1:
      begin
         MessageBox(0, 'GetCommandLine', 'USER', MB_OK);
        // delete custom menu entries (quick'n'dirty)
        SetWindowLong(buf^.hMatWnd, GWL_WNDPROC, buf^.oldProc);
      end;

    end;

Result := CallWindowProc(Pointer(buf^.oldProc), Handle, Msg, wp, lp);



//Result := DefWindowProc(hWnd,Msg,wParam,lParam);


  except
    Result := 0;
  end;



//result :=  DefWindowProc(Handle,Msg,wP,lP);

end;

// hook proc - waits for target window to be created
function MatHookProc(nCode: Integer; wp: wParam; lp: lParam): LongInt; stdcall;
var
  hTemp: hWnd;
  szClass: array[0..255] of Char;
begin
  try
    if (nCode >= HC_ACTION) then
    begin
      Case nCode of
        HCBT_CREATEWND:
        begin



if EnumThreadWindows(GetCurrentThreadId, @hTemp, 0) then
begin
hTemp := HWND(wp);
FillChar(szClass, SizeOf(szClass), 0);
ZeroMemory(@szClass, SizeOf(szClass));
GetWindowText(hTemp, szClass, SizeOf(szClass));
GetClassName(hTemp, szClass, SizeOf(szClass));


            buf^.hMatWnd := htemp;
            buf^.oldProc := GetWindowLong(buf^.hMatWnd, GWL_WNDPROC);
            SetWindowLong(buf^.hMatWnd, GWL_WNDPROC, Integer(@MatWndProc));
end;

        end;
        HCBT_DESTROYWND:
        begin
           {//useless code
          hTemp := HWND(wp);
          FillChar(szClass, 256, 0);
          GetClassName(hTemp, szClass, 256);
          if (szClass = 'Notepad') then
          }



            SetWindowLong(buf^.hMatWnd, GWL_WNDPROC, buf^.OldProc);

        end;
      end;
    end;

    Result := CallNextHookEx(buf^.hMatHook, nCode, wp, lp);
  except
    Result := 0;
  end;
end;

// sets up hook
function SetHook: Boolean; stdcall; export;
begin
  try
    Result := false;
    if (not assigned(buf)) then
    begin
      map := CreateFileMapping(DWord(-1), nil, PAGE_READWRITE, 0, SizeOf(THookRec), 'HookRecMemBlock');
      buf := MapViewOfFile(map, FILE_MAP_ALL_ACCESS, 0, 0, 0);
      buf^.hMatHook := SetWindowsHookEx(WH_CBT, @MatHookProc, hInstance, 0);
      Result := true;
    end;
  except
    Result := false;
  end;
end;

// removes hook
function RemoveHook: Boolean; stdcall; export;
begin
  Result := false;
  if (assigned(buf)) then
  begin
    // tell our new wnd proc to stop subclassing
    // (has to be done in context of target process)
    SendMessage(buf^.hMatWnd, wm_User + 1, 1, 0);
    if (buf^.hMatHook <> 0) then UnhookWindowsHookEx(buf^.hMatHook);
    buf^.hMatHook := 0;
    UnmapViewOfFile(buf);
    buf := nil;
    Result := true;
  end;
end;

// DLL entry point
procedure DllEntry(dwReason: DWord);
begin
  Case dwReason of
    DLL_PROCESS_ATTACH:
    begin
      if (not assigned(buf)) then
      begin
        map := OpenFileMapping(FILE_MAP_ALL_ACCESS, false, 'HookRecMemBlock');
        buf := MapViewOfFile(map, FILE_MAP_ALL_ACCESS, 0, 0, 0);
        CloseHandle(map);
        map := 0;
      end;
    end;
    DLL_PROCESS_DETACH:
    begin
      UnmapViewOfFile(buf);
      buf := nil;
    end;
  end;
end;

exports
  SetHook,
  RemoveHook;

// main
begin
  DisableThreadLibraryCalls(hInstance);
  DllProc := @DLLEntry;
  DllEntry(DLL_PROCESS_ATTACH);
end.
//end DLL

Select allOpen in new window