Zeichnen Bitmap über 3 Tasten in C++ Win32 Anwendung

Question

Ich habe eine Win32-Anwendung, wo ich im Hauptfenster (mit CreateWindowEx erstellt) 3 Tasten platziert. Ich möchte sie durch zwei Zeilen trennen, also habe ich gedacht, eine Bitmap zwischen jeder Schaltfläche zu platzieren, aber wenn ich versuche, das Bild in WM_PAINT zu zeichnen, platziert es nach der letzten Schaltfläche, auch wenn die X- und Y-Koordinaten 0,0 sind. Warum? Soll ich stattdessen ein statisches Steuerelement platzieren und den Bildhintergrund mit STM_SETIMAGE festlegen?

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

Answer 1

Ihr letzter Kommentar wird eine rote Fahne geworfen.

Sie müssen kein Fenster erstellen, um eine schwarze Linie zu zeichnen. Es scheint einige Missverständnisse darüber zu geben, wie das Fenstersystem funktioniert.

Also, um diese zu bauen:

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

würden Sie zuerst Create rufen Sie das Hauptfenster zu erstellen und dann messsage Schleife eingeben (GetMessage, Übersetzen, Versand, etc.). Im WM_CREATE-Handler des Hauptfensters würden Sie dann Button1 und Button2 erstellen, indem Sie den Fensterparameter des Message-Handlers als übergeordnetes Fenster für die Schaltflächen verwenden.

Um den schwarzen Balken zu zeichnen, würden Sie einen Handler für die WM_ERASEBKGND Nachricht im Hauptfenster des Meldungshandlers hinzufügen und in diesem Handler Sie den Client-Bereich löschen (durch Aufrufen von DefWindowProc) und dann den schwarzen Balken zeichnen.

Das Zeichnen der Schaltflächen sollte von den Handlern WM_ERASEBKGND/WM_PAINT für die Schaltflächenfenster und nicht durch das Hauptfenster behandelt werden.

EDIT: Hier ist ein einfaches Programm, zwei Tasten zu zeigen, und ein schwarzer Balken:

#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; 
}