How to create a pure winapi window

The goal is to create communication between the two threads, o开发者_如何学编程ne of which is the main thread. What I'm searching for is creating a window that takes less resource and use it to only receive messages.

What could you refer me to?

What you need to do is set up a message loop in your thread, and use AllocateHWnd in your main thread to send message backward and forwards. It's pretty simple.

In your thread execute function have the following:

procedure TMyThread.Execute;
begin
  // this sets up the thread message loop
  PeekMessage(LMessage, 0, WM_USER, WM_USER, PM_NOREMOVE);

  // your main loop
  while not terminated do
  begin
    // look for messages in the threads message queue and process them in turn.
    // You can use GetMessage here instead and it will block waiting for messages
    // which is good if you don't have anything else to do in your thread.
    while PeekMessage(LMessage, 0, WM_USER, $7FFF, PM_REMOVE) do
    begin
      case LMessage.Msg of
      //process the messages
      end;
    end;

    // do other things. There would probably be a wait of some 
    // kind in here. I'm just putting a Sleep call for brevity
    Sleep(500);

  end;
end;

To send a message to your thread, do something like the following:

PostThreadMessage(MyThread.Handle, WM_USER, 0, 0);

On the main thread side of things, set up a window handle using AllocateHWnd (in the Classes unit), passing it a WndProc method. AllocateHWnd is very lightweight and is simple to use:

TMyMessageReciever = class
private
  FHandle: integer;

  procedure WndProc(var Msg: TMessage);

public
  constructor Create;
  drestructor Destroy; override;

  property Handle: integer read FHandle;

end;

implementation

constructor TMyMessageReciever.Create;
begin
  inherited Create;
  FHandle := Classes.AllocateHWnd(WndProc);
end;

destructor TMyMessageReciever.Destroy;
begin
  DeallocateHWnd(FHandle);
  inherited Destroy;
end;

procedure TMyMessageReciever.WndProc(var Msg: TMessage);
begin
  case Msg.Msg of
  //handle your messages here
  end;
end;

And send messages with either SendMessage, which will block till the message has been handled, or PostMessage which does it asynchronously.

Hope this helps.

This is what message-only windows are for. I have written a sample Delphi send+receive system at a previous question.

In OmniThread Library by Gabr offers a nice little unit DSiWin32, you use that to create message windows, or you can just use OmniThread to do the communication for you.