Grafik einfügen

[silvanm]

Hallo zusammen

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.

[Elektronix]

Das hängt von der Fragestellung ab. Ein Icon in die Kopfleiste zu bringen, läuft anders, als eine Graphik auf einen Button (ist auch ein Fenster!) zu setzen. Das wiederum anders als eine Graphik in die Schaltfläche einer Toolbar (ebenfalls alles Fenster), und das wiederum anders als ein Bild in einem Dokumentfenster.

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.

[Showball]

suche mal bei google nach BitBlt, bitmaps, WinAPI!

Der sollte dir eine menge ausspucken!

[silvanm]

Ich möchte ein ganz normales .bmp Bild in das ganz normale hwnd-Fenster einblenden, welches mit CreateWindow erstellt wurde. Das das mit WinAPI geht ist mir schon klar, die Frage ist nur, wie?

LG

[Swordfish]

Friss und *:

#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

[0xDEADBEEF]

Entweder so wie es Swordfish gemacht hat oder schau einfach mal nach dem STATIC Steuerelement in der MSDN, damit kannst du ohne viel Aufwand eine Bitmap zeichnen.