Draw bitmap over 3 buttons in C++ Win32 Application

i have a win32 application where i placed in the main window (created with CreateWindowEx) 3 buttons. I would like to separate them by two lines, so i thought to place a bitmap between each button but when i try to draw the image inside WM_PAINT it places it after the last button, al开发者_如何学Pythonso if the X and Y coordinates are 0,0. Why? Should I instead place a static control and set the image background with STM_SETIMAGE?

EDIT 1

hdc = BeginPaint(hWnd, &ps);
HDC hdcMem;
hdcMem = CreateCompatibleDC(hdc);
BITMAP bm;
HBITMAP oldbitmap;

GetObject(test, sizeof(bm), &bm);
oldbitmap = (HBITMAP)SelectObject(hdcMem, test);

BitBlt(hdc, 10, 10, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);  

SelectObject(hdcMem, oldbitmap);  
DeleteObject(oldbitmap);
DeleteDC(hdcMem);

EndPaint(hWnd, &ps);

EDIT 2

ImageHost.org http://g.imagehost.org/0076/image-example.png

---

Your last comment has thrown up a red flag.

You do not need to create a window in order to draw a black line. There appears to be some misunderstanding on how the window system works.

So, in order to build this:

|--------------------------------|
|MainWindow    B                 |
|              l                 |
|  |--------|  a  |--------|     |
|  |Button1 |  c  |Button2 |     |
|  |        |  k  |        |     |
|  |        |     |        |     |
|  |        |  B  |        |     |
|  |        |  a  |        |     |
|  |--------|  r  |--------|     |
|--------------------------------|

You would first call CreateWindow to create the MainWindow and then enter your messsage loop (GetMessage, Translate, Dispatch, etc). In the WM_CREATE handler of the main window you would then create Button1 and Button2 using the message handler's window parameter as the parent window for the buttons.

To draw the black bar, you would add a handler for the WM_ERASEBKGND message in the main window's message handler and in that handler you'd clear the client area (by calling DefWindowProc) and then draw the black bar.

The drawing of the buttons should be handled by the WM_ERASEBKGND/WM_PAINT handlers for the button windows, not by the main window.

EDIT: Here's a simple program to show two buttons and a black bar:

#define WIN32_MEAN_AND_LEAN
#include <windows.h>

// a helper function to create two buttons
void CreateButtons (HWND parent)
{
  // create two button
  // Here, I've used the standard button class. If you want to have red buttons,
  // either create a new class for the buttons and implement all the functionality
  // yourself, or sub class the standard button and override the drawing functions.
  CreateWindowEx (0,
                  TEXT ("BUTTON"),
                  TEXT ("Button1"),
                  WS_CHILD | WS_VISIBLE,
                  10,
                  10,
                  100,
                  50,
                  parent,
                  0,
                  reinterpret_cast <HINSTANCE> (GetWindowLongPtr (parent, GWL_HINSTANCE)),
                  0);

  CreateWindowEx (0,
                  TEXT ("BUTTON"),
                  TEXT ("Button2"),
                  WS_CHILD | WS_VISIBLE,
                  140,
                  10,
                  100,
                  50,
                  parent,
                  0,
                  reinterpret_cast <HINSTANCE> (GetWindowLongPtr (parent, GWL_HINSTANCE)),
                  0);

}

LRESULT CALLBACK MainWindowProc (HWND window, UINT message, WPARAM w_param, LPARAM l_param)
{
  LRESULT
    result;

  bool
    use_default_proc = true;

  switch (message)
  {
  case WM_CREATE:
    // when the window is created, create the two buttons!
    CreateButtons (window);
    break;

  case WM_DESTROY:
    // when the window is finished with, call PostQuitMessage to exit the message loop
    PostQuitMessage (0);
    use_default_proc = false;
    result = 0;
    break;

  case WM_ERASEBKGND:
    // here we draw the black line between the two buttons using a solid colour filled rectangle.
    // this can just as easily be done in the WM_PAINT handler
    {
      // DefWindowProc will clear the window using the WNDCLASSEX.hbrBackground member
      result = DefWindowProc (window, message, w_param, l_param);
      use_default_proc = false;

      // get the DC to draw with
      HDC
        dc = reinterpret_cast <HDC> (w_param);

      // draw the black bar
      RECT
        rect = {120, 0, 130, 70};

      FillRect (dc, &rect, reinterpret_cast <HBRUSH> (GetStockObject (BLACK_BRUSH)));
    }
    break;
  }

  if (use_default_proc)
  {
    result = DefWindowProc (window, message, w_param, l_param);
  }

  return result;
}

int __stdcall WinMain (HINSTANCE instance, HINSTANCE previous_instance, LPSTR command_line, int show_command)
{
  // create a window class for the main window
  WNDCLASSEX
    window_class = 
    {
      sizeof window_class,
      CS_HREDRAW | CS_VREDRAW,
      MainWindowProc,
      0,
      0,
      instance,
      0,
      LoadCursor (0, IDC_ARROW),
      reinterpret_cast <HBRUSH> (COLOR_WINDOW + 1),
      0,
      TEXT ("MainWindowClass"),
      0
    };

  // register the window class
  RegisterClassEx (&window_class);

  // create the main window
  HWND
    window = CreateWindowEx (WS_EX_APPWINDOW,
                             TEXT ("MainWindowClass"),
                             TEXT ("Example Window"),
                             WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             0,
                             0,
                             instance,
                             0);

  bool
    quit = false;

  while (!quit)
  {
    MSG
      message;

    int
      error_code;

    switch (GetMessage (&message, 0, 0, 0))
    {
    case 0: // WM_QUIT processed
      quit = true;
      break;

    case -1: // an error
      error_code = GetLastError ();
      quit = true;
      break;

    default: // pass the message on to the window...
      TranslateMessage (&message);
      DispatchMessage (&message);
      break;
    }
  }

  return 0;
}