zapisywanie bitmapy do pliku

0

Chcęzrobić program który zrobi screnshota wycinka ekranu i potem to zapisze jako bmp do pliku
mam przykladowy program z ksiazki programowanie z windows api w języku c++ zgubiłem cd więc program przepisywałem z książki ze strony 222 jedank przepisany jest bezblednie a nie umie go uruchomic moze ktos go przegladnie i poprawi sa dziwne błędy errory w nim : '=' : cannot convert from 'char *const ' to 'LPCWSTR'
nie idzie nawet tego uruchomic bitmapa=( HBITMAP ) LoadImage( NULL, "c:\1\test1.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE ); bo zwraca jakiś bład

z tego programu poczebuje tylko wykorzystać funkcje BitBlt i zapis do pliku bmp może ktoś umie pokazać mi w prosty sposób jak to zrobic może być na innym przykładzie niż ten

// bit mapa mm.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"


#include <iostream>
#include <windows.h>
#include<stdio.h>
#include<time.h>
#include <tchar.h>
using namespace std;
#define SLEEP	25

//DEKLARACJE
LRESULT CALLBACK ProceduraOkna(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
bool TworzPlikBitmapy(void);
void RysowanieCalegoOkna(HWND hwnd,unsigned char jakWywolana);
void WyswietlBitmape(HDC hdc);
void NapisNaBelceTytuowejOkna(HWND hwnd);
bool ZapiszBitmapeDoPliku(char * sciezkaDoPliku,BITMAPFILEHEADER* bfh,BITMAPINFOHEADER* bif,unsigned char* daneObrazu);

//DEFINICJE
#define SZEROKOSC_BITMAPY 256
#define WYSOKOSC_BITMAPY 256
#define Z_PETLI_WIADOMOSCI 0
#define Z_PROCEDURY_OKNA 1
char* const nazwaKlasyOkna="StandardoweOkno";
bool czyAktywna=true;

//WINMAIN
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
	//definiujemy klase okna
	WNDCLASSEX wndclassex;

	wndclassex.cbSize=sizeof(WNDCLASSEX);
	wndclassex.style=CS_VREDRAW|CS_HREDRAW;
	wndclassex.lpfnWndProc=ProceduraOkna;
	wndclassex.cbClsExtra=0;
	wndclassex.cbWndExtra=0;
	wndclassex.hInstance=hInstance;
	wndclassex.hIcon=LoadIcon(0,(LPCTSTR)IDI_APPLICATION);
	wndclassex.hCursor=LoadCursor(0,(LPCTSTR)IDC_ARROW);
	wndclassex.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);
	wndclassex.lpszMenuName=0;
	wndclassex.lpszClassName=nazwaKlasyOkna;
	wndclassex.hIconSm=LoadIcon(0,(LPCTSTR)IDI_APPLICATION);

	//rejestrujemy klase okna
	RegisterClassEx(&wndclassex);
	//tworzymy okno
	HWND hwnd=0;
	hwnd=CreateWindowEx(0,nazwaKlasyOkna,"Spektrum barw",WS_OVERLAPPEDWINDOW^WS_THICKFRAME,100,60,400,300,0,0,hInstance,0);
	//wyswietlamy i odswierzamy okno
	ShowWindow(hwnd,SW_NORMAL);
	UpdateWindow(hwnd);
	//peta wiadomosci
	MSG msg;
	for(;;)
	{
		if(PeekMessage(&msg,0,0,0,PM_REMOVE)!=0)
		{
			if(msg.message==WM_QUIT)break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		
		if(czyAktywna==false)
		{
			WaitMessage();
		}
		else
		{
			RysowanieCalegoOkna(hwnd,Z_PETLI_WIADOMOSCI);

		}
	}//koniec for

	return (int)msg.wParam;
}

//DEFINICJE FUNKCJI

LRESULT CALLBACK ProceduraOkna(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{//definiujemy zmienna ,w ktorej zapamietamy informacje,czy utworzenie bitmapy przebieglo pomyslnie
	static bool czyUtworzonoBitmape=false;

	switch(message)
	{
		//okno zostalo utworzone ,funkcja CreateWindowEx wywolala procedure okna,wysylajac do niej wiadomosc WM_CREATE
	case WM_CREATE:
		czyUtworzonoBitmape=TworzPlikBitmapy();
		return 0;
		//wystapila koniecznosc odsiwerzenia okna
	case WM_PAINT:
		if(czyUtworzonoBitmape==true)
		{
			RysowanieCalegoOkna(hWnd,Z_PROCEDURY_OKNA);
		}
		else
		{
			ValidateRect(hWnd,0);
		}
		return 0;
		//przechwycenie procesu zamykania okna,pytamy urzytkownika,czy napewno chce zamknac okno programu i zakonczyc jego prace
	case WM_CLOSE:
		if(IDYES==MessageBox(hWnd,"Czy na penwno zamknac okno?","?",MB_YESNO|MB_ICONQUESTION))
			return DefWindowProc(hWnd,message,wParam,lParam);
		else
			return 0;
		//zatrzymanie badz aktywaoanie pracy programu w chwili,gdy okno traci lub odzyskuje aktywnosc
	case WM_ACTIVATE:
		if(LOWORD(wParam)==WA_INACTIVE)
		{
			czyAktywna=false;
		}
		else
		{
			czyAktywna=true;
		}
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}//koniec switch
	return DefWindowProc(hWnd,message,wParam,lParam);
}
/////////////////////////////////////////////////////

void RysowanieCalegoOkna(HWND hwnd,unsigned char jakWywolana)
{
	//jezeli funkcja zostala wywolana z wnetrza procedury okna//w odpowiedzi na wiadomosc WM_PAINT
	// wyswietlamy utworzona bitmape
	if(jakWywolana==Z_PROCEDURY_OKNA)
	{
		//pobieramy uchwyt kontekstu urzadzenia rboczego okna
		HDC hdc=0;
		hdc=GetDC(hwnd);
		//wyswietlamy bitmape
		WyswietlBitmape(hdc);
		//zatwierdzamy caly obszar roboczy okna i zwalniamy kontekst urzadzenia
		ValidateRect(hwnd,0);
		ReleaseDC(hwnd,hdc);
	}
	//jezeli funkcja zostala wywolana z wnetrza petli wiadomosci,uaktualnimy wylacznie napis na belce tytuowej okna
	if(jakWywolana==Z_PETLI_WIADOMOSCI)
	NapisNaBelceTytuowejOkna(hwnd);
}
/////////////////////////////////////////////////////
void WyswietlBitmape(HDC hdc)
{
	//definiujemy niezbedne zmienne
	HBITMAP bitmapa=0;
	HDC hdcPamieciowy=0;
	HGDIOBJ gdiObj=0;
	//ladujemy bitmape
	bitmapa=( HBITMAP ) LoadImage( NULL, "c:\\1\\test1.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
	// jezeli bitmapa nie zostala zaladowana opuszczamy funckje
	if(bitmapa==0)
		return;
	//tworzymy pamieciowy kontekst urzadzenia podlaczamy do niego zaladowana bitmape
	hdcPamieciowy=CreateCompatibleDC(0);
	gdiObj=SelectObject(hdcPamieciowy,bitmapa);
	//wyswietlamy bitmape
	BitBlt(hdc,0,0,SZEROKOSC_BITMAPY,WYSOKOSC_BITMAPY,hdcPamieciowy,0,0,SRCCOPY);
	//przywracamy poczatkowe ustawienia pamieciowego kontekstu urzadzenia
	SelectObject(hdcPamieciowy,gdiObj);
	//usuwamy kontekst
	DeleteDC(hdcPamieciowy);
	//usuwamy zaladowana do pamieci bitmape
	DeleteObject(bitmapa);
}
////////////////////////////////////////////////////////////////////////////////

void NapisNaBelceTytuowejOkna(HWND hwnd)
{
	//tablice znakow
	char tab[40]={'\0'};
	static char godzinaA[9]={'\0'};
	static char godzinaB[9]={'\0'};
	//statyczne zmienne po wyjsciu z funkcji pozostaja nienaruszone w pamieci,istnieja caly czas,od poczatku do konca pracy programu

	//pobieramy lancuch znakow okreslajacy aktualny stan zegara systemowego
	_strtime_s(godzinaA,9);
	//sprawdzamy,czy tekst znajdujacy sie w tablicy godzinaA jest identyczny z tekstem w tablicy godzinaB
	//jkesli tak jest napis na belce tytuowej nie wymaga odswierzania, w przeciwnym wypadku kopiujemy do tablicy godzinaB 
	//zawartosc tablicy godzinaA
	if(0==strcmp(godzinaA,godzinaB))
	{
		return;
	}
	else
	{
		strcpy_s(godzinaB,9,godzinaA);
	}
	//utworzenie wyswietlanego tekstu
	sprintf_s(tab,sizeof(tab),"spektrum barw[%s]",godzinaA);
	//ustawienie tekstu na belce tytuowej okna
	SetWindowText(hwnd,tab);
}

//////////////////////////////////////////////////////////////////////
bool TworzPlikBitmapy(void)
{
	//tworzymy bufor dla 24 bitowej bitmapy o rozmiarze 256x256 pikseli
	RGBTRIPLE buforObrazu[WYSOKOSC_BITMAPY][SZEROKOSC_BITMAPY];
	//czyscimy bufor
	ZeroMemory(buforObrazu,sizeof(buforObrazu));
	//ustawiamy kolor kazdego piksela
	for(int i=0;i<WYSOKOSC_BITMAPY;i++)
		for(int j=0;j<SZEROKOSC_BITMAPY;j++)
		{
			buforObrazu[i][j].rgbtBlue=j;
			buforObrazu[i][j].rgbtGreen=255-i;
			buforObrazu[i][j].rgbtRed=i;
		}
	//tworzymy naglowek pliku bitmapy
	BITMAPFILEHEADER naglowekBFH;
	naglowekBFH.bfType=*((unsigned short*)"BM");
	naglowekBFH.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(buforObrazu);
	naglowekBFH.bfReserved1=0;
	naglowekBFH.bfReserved2=0;
	naglowekBFH.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	//tworzymy naglowek informacyjny bitmapy
	BITMAPINFOHEADER naglowekBIH;
	naglowekBIH.biSize=sizeof(BITMAPINFOHEADER);
	naglowekBIH.biWidth=SZEROKOSC_BITMAPY;
	naglowekBIH.biHeight=WYSOKOSC_BITMAPY;
	naglowekBIH.biPlanes=1;
	naglowekBIH.biBitCount=24;
	naglowekBIH.biCompression=BI_RBG;//?????
	naglowekBIH.biSizeImage=0;
	naglowekBIH.biXPelsPerMeter=0;
	naglowekBIH.biYPelsPerMeter=0;
	naglowekBIH.biClrUsed=0;
	naglowekBIH.biClrImportant=0;

	//zapisujemy bitmape na dysku w pliku
	return ZapiszBitmapeDoPliku("c:\\1\\test2.bmp",&naglowekBFH,&naglowekBIH,(unsigned char*)buforObrazu);
}
///////////////////////////////////////////////////////////////////////////////////////////

bool ZapiszBitmapeDoPliku(char * sciezkaDoPliku,BITMAPFILEHEADER* bfh,BITMAPINFOHEADER* bih,unsigned char* daneObrazu)
{
	//funkcja potrafi poprawnie tworzyc tylko bitmapy 24 i 32 bitowe
	if((bih->biBitCount!=24)&&(bih->biBitCount!=32))
		return false;
	//otwieramy plik wskazywany przez parametr sciezkadopliku,plik zostaje otwarty do zapisu w formie binarnej,nastepnie sprawdzamy 
	//czy otwarcie pliku przebieglo pomyslnie,jezeli wartosc funkcji zwrocona przez funkcje good jest rozna od true,funkcja zwraca 
	//wartosc false,co oznacza niepowodzenie
	std::fstream plik;//?????????
		plik.open(sciezkaDoPliku,std::ios::out|std::ios::binary);
	if(plik.good()!=true)
		return false;
	//umieszczamy w pliku naglowek pliku i naglowek informacyjny
	plik.write((char*)bfh,sizeof(BITMAPFILEHEADER));
	plik.write((char*)bih,sizeof(BITMAPINFOHEADER));
	//obliczamy ile bajtow przypada na jeden bajt obrazu
	unsigned long ileBajtowNaLinie=(bih->biWidth * bih->biBitCount)/8;
	//obliczamy,ile bajtow pochlania obraz,uzyskamny wynik pomniejszamy o liczbe bajtow przypadajaca na jeden wierszta 
	//zmienna posluzy jako indeks do okreslenia poczatkowego bajta kazdego wiersza zapisywanego do pliku
	unsigned long ileZapisano=(bih->biWidth * bih->biHeight * bih->biBitCount/8)-ileBajtowNaLinie;
	//obliczamy ile bajtow nalezy dopisac do wiersza,aby przypadajaca na niego liczba bajtow byla wielokrotnascia
	// liczby 4
	 unsigned long ileDopelnienia=ileBajtowNaLinie%4;
	 //definicja tablicy ,ktorej urzyjemyu do dopelnienia wierszy
	 char tabDopelnienia[4]={0};
	 //zapisujemy do pliku kazdy wiersz obrazu,rozpoczynajac od ostatniego,a konczac na pierwszym
	 for(long i=0;i<bih->biHeight;i++)
	 {
		 //zapisujemy do pliku jeden wiersz obrazu
		 plik.write(
			 (char*)&daneObrazu[ileZapisano],ileBajtowNaLinie);
		 //jezeli wymaga dopelnienia to dopisujemy odpowiednia ilosc bajtow
		 if(ileDopelnienia!=0)
			 plik.write(tabDopelnienia,ileDopelnienia);
		 //zmieniamy wartosc zmiennej ileZapisano tak ,aby wskazywala na poczatke wiersza o jeden numer wczesniejszego
		 ileZapisano-=ileBajtowNaLinie;
	 }
	 //zamykamy plik
	 plik.close();

	 return true;
} 
0

przerobilem ten program wyzej na taki

 // 123.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <windows.h>
#include <tchar.h>

bool TworzPlikBitmapy(void);
bool ZapiszBitmapeDoPliku(char * sciezkaDoPliku,BITMAPFILEHEADER* bfh,BITMAPINFOHEADER* bif,unsigned char* daneObrazu);
#define SZEROKOSC_BITMAPY 256
#define WYSOKOSC_BITMAPY 256



int _tmain(int argc, _TCHAR* argv[])
{	
		system("pause");
		SetCursorPos(200, 200);		
		mouse_event(MOUSEEVENTF_LEFTDOWN,0 ,0,0,0);
		static bool czyUtworzonoBitmape=false;
		czyUtworzonoBitmape=TworzPlikBitmapy();


		Sleep(100);
		system("pause");
	return 0;
}

////////////////////////////
bool TworzPlikBitmapy(void)
{
        //tworzymy bufor dla 24 bitowej bitmapy o rozmiarze 256x256 pikseli
        RGBTRIPLE buforObrazu[WYSOKOSC_BITMAPY][SZEROKOSC_BITMAPY];
        //czyscimy bufor
        ZeroMemory(buforObrazu,sizeof(buforObrazu));
        //ustawiamy kolor kazdego piksela
        for(int i=0;i<WYSOKOSC_BITMAPY;i++)
                for(int j=0;j<SZEROKOSC_BITMAPY;j++)
                {
                        buforObrazu[i][j].rgbtBlue=j;
                        buforObrazu[i][j].rgbtGreen=255-i;
                        buforObrazu[i][j].rgbtRed=i;
                }
        //tworzymy naglowek pliku bitmapy
        BITMAPFILEHEADER naglowekBFH;
        naglowekBFH.bfType=*((unsigned short*)"BM");
        naglowekBFH.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(buforObrazu);
        naglowekBFH.bfReserved1=0;
        naglowekBFH.bfReserved2=0;
        naglowekBFH.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
        //tworzymy naglowek informacyjny bitmapy
        BITMAPINFOHEADER naglowekBIH;
        naglowekBIH.biSize=sizeof(BITMAPINFOHEADER);
        naglowekBIH.biWidth=SZEROKOSC_BITMAPY;
        naglowekBIH.biHeight=WYSOKOSC_BITMAPY;
        naglowekBIH.biPlanes=1;
        naglowekBIH.biBitCount=24;
        naglowekBIH.biCompression=BI_RBG;//?????
        naglowekBIH.biSizeImage=0;
        naglowekBIH.biXPelsPerMeter=0;
        naglowekBIH.biYPelsPerMeter=0;
        naglowekBIH.biClrUsed=0;
        naglowekBIH.biClrImportant=0;
 
        //zapisujemy bitmape na dysku w pliku
        return ZapiszBitmapeDoPliku("c:\\1\\test2.bmp",&naglowekBFH,&naglowekBIH,(unsigned char*)buforObrazu);
}
///////////////////////////////////////////////////////////////////////////////////////////
 
bool ZapiszBitmapeDoPliku(char * sciezkaDoPliku,BITMAPFILEHEADER* bfh,BITMAPINFOHEADER* bih,unsigned char* daneObrazu)
{
        //funkcja potrafi poprawnie tworzyc tylko bitmapy 24 i 32 bitowe
        if((bih->biBitCount!=24)&&(bih->biBitCount!=32))
                return false;
        //otwieramy plik wskazywany przez parametr sciezkadopliku,plik zostaje otwarty do zapisu w formie binarnej,nastepnie sprawdzamy 
        //czy otwarcie pliku przebieglo pomyslnie,jezeli wartosc funkcji zwrocona przez funkcje good jest rozna od true,funkcja zwraca 
        //wartosc false,co oznacza niepowodzenie
        std::fstream plik;//?????????
                plik.open(sciezkaDoPliku,std::ios::out|std::ios::binary);
        if(plik.good()!=true)
                return false;
        //umieszczamy w pliku naglowek pliku i naglowek informacyjny
        plik.write((char*)bfh,sizeof(BITMAPFILEHEADER));
        plik.write((char*)bih,sizeof(BITMAPINFOHEADER));
        //obliczamy ile bajtow przypada na jeden bajt obrazu
        unsigned long ileBajtowNaLinie=(bih->biWidth * bih->biBitCount)/8;
        //obliczamy,ile bajtow pochlania obraz,uzyskamny wynik pomniejszamy o liczbe bajtow przypadajaca na jeden wierszta 
        //zmienna posluzy jako indeks do okreslenia poczatkowego bajta kazdego wiersza zapisywanego do pliku
        unsigned long ileZapisano=(bih->biWidth * bih->biHeight * bih->biBitCount/8)-ileBajtowNaLinie;
        //obliczamy ile bajtow nalezy dopisac do wiersza,aby przypadajaca na niego liczba bajtow byla wielokrotnascia
        // liczby 4
         unsigned long ileDopelnienia=ileBajtowNaLinie%4;
         //definicja tablicy ,ktorej urzyjemyu do dopelnienia wierszy
         char tabDopelnienia[4]={0};
         //zapisujemy do pliku kazdy wiersz obrazu,rozpoczynajac od ostatniego,a konczac na pierwszym
         for(long i=0;i<bih->biHeight;i++)
         {
                 //zapisujemy do pliku jeden wiersz obrazu
                 plik.write(
                         (char*)&daneObrazu[ileZapisano],ileBajtowNaLinie);
                 //jezeli wymaga dopelnienia to dopisujemy odpowiednia ilosc bajtow
                 if(ileDopelnienia!=0)
                         plik.write(tabDopelnienia,ileDopelnienia);
                 //zmieniamy wartosc zmiennej ileZapisano tak ,aby wskazywala na poczatke wiersza o jeden numer wczesniejszego
                 ileZapisano-=ileBajtowNaLinie;
         }
         //zamykamy plik
         plik.close();
 
         return true;
} 

sa 2 bledy ktorych nie wiem jak poprawic i czy ten program z porawionymi bledami bedzie juz dzialal dobrze czyli zapisywal bmp do pliku?

0

brakowalo #include <fstream>

jak zamienic to:
for(int i=0;i<WYSOKOSC_BITMAPY;i++)
for(int j=0;j<SZEROKOSC_BITMAPY;j++)
{
buforObrazu[i][j].rgbtBlue=j;
buforObrazu[i][j].rgbtGreen=255-i;
buforObrazu[i][j].rgbtRed=i;
}

co mi random wpisuje piksele do tablicy na wycinek pulpiyu scren ktory chce zapisac do pliku?

0

szkoda że nikt nie odpisuje znowu cos nowego zrobiłem:

int _tmain(int argc, _TCHAR* argv[])
{	
		system("pause");
		SetCursorPos(200, 200);		
		mouse_event(MOUSEEVENTF_LEFTDOWN,0 ,0,0,0);


HWND okno=GetDesktopWindow();
HDC bitmapa_zrodlowa = GetWindowDC(okno);
RECT re;
GetWindowRect(okno,&re);
int w = re.right, h = re.bottom;
HDC bitmapa_skopiowana = CreateCompatibleDC(0);
HBITMAP bm = CreateCompatibleBitmap(bitmapa_zrodlowa,w,h);
SelectObject(bitmapa_skopiowana,bm);
BitBlt(bitmapa_skopiowana,0,0,w,h,bitmapa_zrodlowa,0,0,w,h,SRCCOPY);

//BitBlt(kontMapy,200,300,300,400,kont,SZEROKOSC,WYSOKOSC,SRCCOPY);
    	Sleep(100);
		system("pause");
	return 0;
} 

chcę żeby to kopiowalo pulpit z wszystkimi włączonymi oknami taki screnshot i teraz chce go zapiać do pliku

0

teraz mam tyle tego na dzisiaj to wystarczy :
czy po wywołaniu tej funkcji:
BitBlt(bitmapa_skopiowana,0,0,w,h,bitmapa_zrodlowa,w,h,SRCCOPY);

mam zaisany screnshot w bitmapa_skopiowana i jak tak to w jaki sposób można uzyskać dostęp do mojego screnshota

#include "stdafx.h"
#include <iostream>
#include <windows.h>
#include <tchar.h>
#include <fstream>


#define SZEROKOSC 100
#define	WYSOKOSC 100




int _tmain(int argc, _TCHAR* argv[])
{	
		system("pause");
		SetCursorPos(100, 200);		
		mouse_event(MOUSEEVENTF_LEFTDOWN,0 ,0,0,0);

	BYTE *bits; 
	HWND okno=GetDesktopWindow();
	HDC bitmapa_zrodlowa = GetWindowDC(okno);
	RECT re;
	GetWindowRect(okno,&re);
	int w = re.right, h = re.bottom;
	HDC bitmapa_skopiowana = CreateCompatibleDC(bitmapa_zrodlowa);
	HBITMAP bmpDC = CreateCompatibleBitmap(bitmapa_zrodlowa,w,h);
	HGDIOBJ objHDC = SelectObject(bitmapa_skopiowana,bmpDC);
	BitBlt(bitmapa_skopiowana,0,0,w,h,bitmapa_zrodlowa,w,h,SRCCOPY);
	SelectObject(bitmapa_skopiowana, bitmapa_zrodlowa);  
	DeleteDC(bitmapa_skopiowana); 
	ReleaseDC(0,bitmapa_zrodlowa);
	HANDLE hf;
	plik=CreateFile(_T("sample11.bmp"),GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
	BITMAPFILEHEADER naglowek;
	BITMAPINFO infor;

	ZeroMemory(&naglowek,sizeof(naglowek));
	naglowek.bfType=0x4d42; 
	naglowek.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	naglowek.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(bitmapa_skopiowana);
	naglowek.bfReserved1=0; 
	naglowek.bfReserved2=0;

	
	infor.bmiHeader.biBitCount=24; 
	infor.bmiHeader.biClrImportant=0;
    infor.bmiHeader.biClrUsed=0;
	infor.bmiHeader.biCompression=BI_RGB; 
	infor.bmiHeader.biHeight=h;
    infor.bmiHeader.biPlanes=1; 
	infor.bmiHeader.biSize=40; 
	infor.bmiHeader.biSizeImage=w*h*3;
	//bi.bmiHeader.biSizeImage=w*h*3;
    infor.bmiHeader.biWidth=w; 
	infor.bmiHeader.biXPelsPerMeter=0; 
	infor.bmiHeader.biYPelsPerMeter=0;
    infor.bmiColors[0].rgbBlue=0; 
	infor.bmiColors[0].rgbGreen=0; 
	infor.bmiColors[0].rgbRed=0; 
	infor.bmiColors[0].rgbReserved=0;

	DWORD writ; 
	WriteFile(plik,& naglowek, sizeof(naglowek), &writ, NULL);
	WriteFile(plik, &infor->bmiHeader, sizeof(infor->bmiHeader), &writ, NULL);
	WriteFile(plik, bits, infor->bmiHeader.biSizeImage, &writ, NULL);
	CloseHandle(plik);
	


//BitBlt(kontMapy,200,300,300,400,kont,SZEROKOSC,WYSOKOSC,SRCCOPY);
    	Sleep(100);
		system("pause");
	return 0;
} 

1 użytkowników online, w tym zalogowanych: 0, gości: 1