Ich habe eine Frage: Da ich von C++ noch keine grosse Ahnung habe, wüsste ich gerne, wie man in ein Fenster ein Bild einfügt. Ich weiss, dass man das irgendwie laden muss, dann in den Speicher schreiben und schliesslich ins Fenster kopieren. Doch der Compiler spuckt nur Fehler. Wie geht es denn genau?

Ich wäre über Antwort wirklich sehr dankbar.

Davon abgesehen ist das keine frage von C++, sondern von WinAPI. Und die ist, obwohl selbst in C geschrieben, (neben anderen) in C, C++, Delphi, Pascal, FreeBasic und VisualBasic nutzbar.

Ich weiß, das hilft Dir jetzt nicht viel. Aber das liegt an Deiner unkonkreten Frage.

Der sollte dir eine menge ausspucken!

LG

#include <string>

#include <windows.h>

const unsigned int idm_load_image  = 1;
const unsigned int idm_exit        = 2;

std::wstring get_last_error_msg( ) {

	void *message_buffer = 0;

    FormatMessage(

        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        0,
        GetLastError( ),
        MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
        reinterpret_cast< LPTSTR >( &message_buffer ),
        0,
        0
	);

	std::wstring error_message( reinterpret_cast< LPTSTR >( message_buffer ) );

	LocalFree( message_buffer );

	return error_message;
}

bool load_bitmap( HBITMAP &bitmap, HWND window ) {

	wchar_t file_name[ MAX_PATH ] = { 0 };
	OPENFILENAME ofn = { 0 };

	memset( &ofn, 0, sizeof( ofn ) );

	ofn.lStructSize	  = sizeof( ofn );
	ofn.hwndOwner     = window;
	ofn.lpstrFile     = file_name;
	ofn.nMaxFile      = sizeof( file_name ) / sizeof( file_name[ 0 ] );
	ofn.lpstrFilter   = L"Bitmaps\0*.bmp\0All Files\0*.*\0";
	ofn.Flags         = OFN_ENABLESIZING | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

	if( !GetOpenFileName( &ofn ) ) {

            return false;
	}

	bitmap = reinterpret_cast< HBITMAP >( LoadImage( 0, file_name, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE ) );
	return true;
}

LRESULT __stdcall main_window_procedure( HWND window, UINT message, WPARAM wparam, LPARAM lparam ) {

	static HBITMAP bitmap = 0;

	switch( message ) {

		case WM_CREATE:

			return 0;

		case WM_CLOSE:

			DestroyWindow( window );
			return 0;

		case WM_DESTROY:

			DeleteObject( bitmap );
			PostQuitMessage( 0 );
			return 0;

		case WM_PAINT: {

			PAINTSTRUCT ps;

			BeginPaint( window, &ps );

			if( bitmap ) {

				HDC     mem_dc      = CreateCompatibleDC( ps.hdc );
				HBITMAP old_bitmap  = reinterpret_cast< HBITMAP >( SelectObject( mem_dc, bitmap ) );
				RECT    rect        = { 0 };

				GetClientRect( window, &rect );
				BitBlt( ps.hdc, 0, 0, rect.right, rect.bottom, mem_dc, 0, 0, SRCCOPY );

				SelectObject( mem_dc, old_bitmap );
				DeleteDC( mem_dc );
			}

			EndPaint( window, &ps );			   
		}

		case WM_COMMAND:

			if( !HIWORD( wparam ) ) {

				switch( LOWORD( wparam ) ) {

					case idm_load_image: {

						HBITMAP new_bitmap; 

						if( load_bitmap( new_bitmap, window ) &&  !new_bitmap ) {

							MessageBox( window, L"The bitmap couldn't be loaded!", L"Error:", MB_OK );

						} else {

							DeleteObject( bitmap );
							bitmap = new_bitmap;
							InvalidateRect( window, 0, false );
						}
						break;
					}

					case idm_exit:

						DestroyWindow( window );
						break;
				}
			}

			return 0;
	}

	return DefWindowProc( window, message, wparam, lparam );
}

int __stdcall WinMain( HINSTANCE instance, HINSTANCE prev_instance, LPSTR command_line, int show_state ) {

	WNDCLASSEX window_class = { 0 };

	window_class.cbSize             = sizeof( window_class );
	window_class.hbrBackground      = reinterpret_cast< HBRUSH >( COLOR_WINDOW + 1 );
	window_class.hCursor            = reinterpret_cast< HCURSOR >( LoadImage( 0, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED ) );
	window_class.hIcon              = reinterpret_cast< HICON >( LoadImage( 0, IDI_APPLICATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_SHARED ) );
	window_class.hInstance          = instance;
	window_class.lpfnWndProc        = main_window_procedure;
	window_class.lpszClassName      = L"CodeFun Window Class";
	window_class.style              = CS_VREDRAW | CS_HREDRAW;

	ATOM window_class_atom = RegisterClassEx( &window_class );

	if( !window_class_atom ) {

		MessageBox( 0, get_last_error_msg( ).c_str( ), L"Error:", MB_OK );
		return 0;
	}

	HMENU main_menu = CreateMenu( );
	MENUITEMINFO menu_item = { 0 };

	menu_item.cbSize      = sizeof( menu_item );
	menu_item.fMask       = MIIM_ID | MIIM_STRING;
	menu_item.wID         = idm_load_image;
	menu_item.dwTypeData  = L"&Load Image...";

	InsertMenuItem( main_menu, idm_load_image, false, &menu_item );

	menu_item.wID         = idm_exit;
	menu_item.dwTypeData  = L"&Exit";

	InsertMenuItem( main_menu, idm_exit, false, &menu_item );

	HWND main_window = CreateWindowEx(

		WS_EX_OVERLAPPEDWINDOW,
		reinterpret_cast< LPCTSTR >( window_class_atom ),
		L"CodeFun",
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		0,
		main_menu,
		instance,
		0
	);

	if( !main_window ) {

		MessageBox( 0, get_last_error_msg( ).c_str( ), L"Error:", MB_OK );
		return 0;
	}

	UpdateWindow( main_window );
	ShowWindow( main_window, show_state );

	MSG message = { 0 };

	while( GetMessage( &message, 0, 0, 0 ) ) {

		TranslateMessage( &message );
		DispatchMessage( &message );
	}

	return static_cast< int >( message.wParam );
}

greetz, Swordfish