FAQ VC++ et MFCConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
//***************************************************************************** 
// rempli le rectangle donné avec un dégradé de 3 couleurs : Haut, milieu, bas 
//***************************************************************************** 
void RempliDegradeRectHautBas(CDC* pDC,CRect rect 
,short RedHaut,short GrHaut,short BlHaut // couleur de départ du haut 
,short RedMilieu,short GrMilieu,short BlMilieu // couleur du milieu 
,short RedBas,short GrBas,short BlBas) // couleur du bas 
{ 
    short ColorR, ColorG, ColorB; 
  
    int nWidth = rect.Width (); 
    int nHeight = rect.Height (); 
  
    // calcul de constantes intermédiaires 
    short ColorRinterm = RedHaut - RedMilieu; 
    short ColorGinterm = GrHaut - GrMilieu; 
    short ColorBinterm = BlHaut - BlMilieu; 
  
    // remplissage d'une premiere moitiée de rectangle (haut) avec 1er dégradé 
    for(int i = 0; i < nHeight/2; ++i)  
    { 
        rect.SetRect(0, i, nWidth, nHeight/2 + 1); 
        ColorR = RedHaut  - MulDiv(i,ColorRinterm, nHeight/2); 
        ColorG = GrHaut - MulDiv(i,ColorGinterm, nHeight/2); 
        ColorB = BlHaut - MulDiv(i,ColorBinterm, nHeight/2); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
    // calcul de constantes intermédiaires 
    ColorRinterm = RedMilieu - RedBas; 
    ColorGinterm = GrMilieu - GrBas; 
    ColorBinterm = BlMilieu - BlBas; 
  
    // remplissage de la deuxieme moitiée de rectangle (bas) avec 2eme dégradé 
    for( i = nHeight/2; i < nHeight; ++i)  
    { 
        rect.SetRect(0, i, nWidth, nHeight + 1); 
        ColorR = RedMilieu - MulDiv(i-nHeight/2,ColorRinterm/*70*/, nHeight/2); 
        ColorG = GrMilieu - MulDiv(i-nHeight/2,ColorGinterm/*10*/, nHeight/2); 
        ColorB = BlMilieu - MulDiv(i-nHeight/2,ColorBinterm/*10*/, nHeight/2); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
} 
  
//******************************************************************************** 
// rempli le rectangle donné avec un dégradé de 3 couleurs : Gauche, milieu, Droit 
//******************************************************************************** 
void RempliDegradeRectGaucheDroite(CDC* pDC,CRect rect 
   ,short RedGauche,short GrGauche,short BlGauche // couleur de départ de gauche 
   ,short RedMilieu,short GrMilieu,short BlMilieu // couleur du milieu 
   ,short RedDroit,short GrDroit,short BlDroit)  // couleur de droite 
{ 
    short ColorR, ColorG, ColorB; 
  
    int nWidth = rect.Width (); 
    int nHeight = rect.Height (); 
  
    // calcul de constantes intermédiaires 
    short ColorRinterm = RedGauche - RedMilieu; 
    short ColorGinterm = GrGauche - GrMilieu; 
    short ColorBinterm = BlGauche - BlMilieu; 
  
    // remplissage d'une premiere moitiée de rectangle (haut) avec 1er dégradé 
    for(int i = 0; i < nWidth/2; ++i)  
    { 
        rect.SetRect(i, 0, nWidth/2 + 1, nHeight); 
        ColorR = RedGauche  - MulDiv(i,ColorRinterm, nWidth/2); 
        ColorG = GrGauche - MulDiv(i,ColorGinterm, nWidth/2); 
        ColorB = BlGauche - MulDiv(i,ColorBinterm, nWidth/2); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
    // calcul de constantes intermédiaires 
    ColorRinterm = RedMilieu - RedDroit; 
    ColorGinterm = GrMilieu - GrDroit; 
    ColorBinterm = BlMilieu - BlDroit; 
  
    // remplissage de la deuxieme moitiée de rectangle (bas) avec 2eme dégradé 
    for( i = nWidth/2; i < nWidth; ++i)  
    { 
        rect.SetRect(i, 0, nWidth + 1, nHeight); 
        ColorR = RedMilieu - MulDiv(i-nWidth/2,ColorRinterm/*70*/, nWidth/2); 
        ColorG = GrMilieu - MulDiv(i-nWidth/2,ColorGinterm/*10*/, nWidth/2); 
        ColorB = BlMilieu - MulDiv(i-nWidth/2,ColorBinterm/*10*/, nWidth/2); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
} 
  
//********************************************************************* 
// rempli le rectangle donné avec un dégradé de 2 couleurs : Haut, bas 
//********************************************************************* 
void RempliDegradeSimpleHautBas(CDC* pDC,CRect rect 
,short RedHaut,short GrHaut,short BlHaut // couleur de départ du haut 
,short RedBas,short GrBas,short BlBas) // couleur du bas 
{ 
    short ColorR, ColorG, ColorB; 
  
    int nWidth = rect.Width (); 
    int nHeight = rect.Height (); 
  
    // remplissage du rectangle avec dégradé 
    for(int i = 0; i < nHeight; ++i)  
    { 
        rect.SetRect(0, i, nWidth, nHeight + 1); 
        ColorR = RedHaut  - MulDiv(i,RedHaut - RedBas, nHeight); 
        ColorG = GrHaut - MulDiv(i,GrHaut - GrBas, nHeight); 
        ColorB = BlHaut - MulDiv(i,BlHaut - BlBas, nHeight); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
} 
  
//************************************************************************ 
// rempli le rectangle donné avec un dégradé de 2 couleurs : Gauche, droit 
//************************************************************************ 
void RempliDegradeSimpleGaucheDroit(CDC* pDC,CRect rect 
,short RedGauche,short GrGauche,short BlGauche // couleur de départ de gauche 
,short RedDroit,short GrDroit,short BlDroit)  // couleur de droite 
{ 
    short ColorR, ColorG, ColorB; 
  
    int nWidth = rect.Width (); 
    int nHeight = rect.Height (); 
  
    // remplissage du rectangle avec dégradé 
    for(int i = 0; i < nWidth; ++i)  
    { 
        rect.SetRect(i, 0, nWidth + 1, nHeight); 
        ColorR = RedGauche  - MulDiv(i,RedGauche - RedDroit, nWidth); 
        ColorG = GrGauche - MulDiv(i,GrGauche - GrDroit, nWidth); 
        ColorB = BlGauche - MulDiv(i,BlGauche - BlDroit, nWidth); 
        pDC->FillSolidRect(&rect, RGB(ColorR ,ColorG,ColorB)); 
    } 
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
  
HICON GetIconFromFile(LPCTSTR sz) 
{ 
    CString key,ret; 
    char drive[_MAX_DRIVE]; 
    char dir[_MAX_DIR]; 
    char fname[_MAX_FNAME]; 
    char ext[_MAX_EXT]; 
  
    CString szpath,szext; 
    HIMAGELIST hSysImageList; 
    SHFILEINFO shfi; 
  
    int nic; 
    HICON hicon=NULL; 
  
    _splitpath(sz,drive,dir,fname,ext); 
    szext=ext; 
    szpath=sz; 
    if(!(szext.Find(".exe")!=-1 ||  
            szext.Find(".pif")!=-1 || 
            szext.IsEmpty() || 
            strlen(szext)<4 || 
            szext.Find(".lnk")!=-1) && 
            SHGetFileInfo(szext,FILE_ATTRIBUTE_NORMAL,&shfi,sizeof(shfi), 
            SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_SMALLICON)) 
    { 
  
        hicon=shfi.hIcon; 
    } 
    if(!hicon) 
    { 
        hSysImageList=(HIMAGELIST) SHGetFileInfo(szpath,0,&shfi,sizeof(SHFILEINFO), 
                        SHGFI_SYSICONINDEX | SHGFI_SMALLICON); 
  
        if(hSysImageList) 
        { 
            nic=shfi.iIcon; 
            hicon=ImageList_GetIcon(hSysImageList,nic,ILD_NORMAL); 
        } 
    } 
    return hicon; 
}

1
2
3
  
int nResolx=GetSystemMetrics(SM_CXSCREEN); // resolution sur les X 
int nResoly=GetSystemMetrics(SM_CYSCREEN); // resolution sur les Y

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
CMyView::OnDraw(CDC *pDC) 
{ 
    CBitmap Bitmap; 
    CDC MemDC; 
  
    Bitmap.LoadBitmap(IDB_BMPESSAI); // lecture bitmap dans les ressources 
    BITMAP InfosBmp; // structure d'informations. 
    Bitmap.GetBitmap(&InfosBmp); 
    MemDC.CreateCompatibleDC(pDC);// creation d'un DC en memoire 
    MemDC.SelectObject(&Bitmap); // selection du bitmap dans le DC en memoire 
    // transfert final du bitmap dans le dc de la view. 
    pDC->BitBlt( 0,0,InfosBmp.bmWidth, InfosBmp.bmHeight, 
                     &MemDC, 
                     0,0, 
                     SRCCOPY); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
  
CDC::StretchBlt 
BOOL StretchBlt (  
int x,  
int y,  
int nWidth,  
int nHeight,  
CDC* pSrcDC,  
int xSrc,  
int ySrc,  
int nSrcWidth,  
int nSrcHeight,  
DWORD dwRop );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
CMyView::OnDraw(CDC *pDC) 
{ 
    CBitmap Bitmap; 
    CDC MemDC; 
  
    Bitmap.LoadBitmap(IDB_BMPESSAI); // lecture bitmap dans les ressources 
    BITMAP InfosBmp; // structure d'informations. 
    Bitmap.GetBitmap(&InfosBmp); 
    MemDC.CreateCompatibleDC(pDC);// creation d'un DC en memoire 
    MemDC.SelectObject(&Bitmap); // selection du bitmap dans le DC en memoire 
    // transfert final du bitmap dans le dc de la view. 
    // zoom x 2 
    CSize Size(InfosBmp.bmWidth *2 , InfosBmp.bmHeight *2); 
    pDC->DPtoLP(&Size);// si le systeme de coordonnées n'est pas MM_TEXT 
    pDC->StretchBlt( 0, 0, 
                     Size.cx,-Size.cy, 
                     &MemDC, 
                     0, 0, 
                     InfosBmp.bmWidth, InfosBmp.bmHeight, 
                     SRCCOPY);  
}

1
2
  
    pDC->SetStretchBltMode( COLORONCOLOR );

1
2
3
4
  
CDC::GetTextExtent 
CSize GetTextExtent( LPCTSTR lpszString, int nCount ) const; 
CSize GetTextExtent( const CString& str ) const;

1
2
3
4
  
CClientDC dc(this); 
CFont* pFont = dc.SelectObject(m_pMyFont); // sélection d'une fonte . 
CSize size=dc.GetTextExtent(string);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  
void CMyApp::SetLandscapeMode()  
{  
   PRINTDLG pd;  
   pd.lStructSize=(DWORD)sizeof(PRINTDLG);  
   BOOL bRet=GetPrinterDeviceDefaults(&pd);  
   if(bRet)  
   {  
      // protect memory handle with ::GlobalLock and ::GlobalUnlock  
      DEVMODE FAR *pDevMode=(DEVMODE FAR *)::GlobalLock(m_hDevMode);  
      // set orientation to landscape  
      pDevMode->dmOrientation=DMORIENT_LANDSCAPE;  
      ::GlobalUnlock(m_hDevMode);  
   }  
}

1
2
  
HICON CWinApp::LoadIcon( UINT nIDResource ) const;

1
2
3
4
5
6
  
HICON hIcon = (HICON)::LoadImage(   AfxFindResourceHandle(MAKEINTRESOURCE(IDI_MYICONE),RT_GROUP_ICON), 
                                    MAKEINTRESOURCE(IDI_MYICONE), 
                                    IMAGE_ICON, 
                                    16,16,LR_DEFAULTSIZE); 
/*CStatic */m_MyStatic.SetIcon( hIcon );

1
2
3
  
HICON hIcon =m_MyStatic.GetIcon(); 
if(hIcon) ::DestroyIcon(hIcon);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
  
/*******************************************************************************/ 
// DDBToDIB- Creates a DIB from a DDB 
// bitmap- Device dependent bitmap 
// dwCompression- Type of compression - see BITMAPINFOHEADER 
// pPal- Logical palette 
/*******************************************************************************/ 
HANDLE DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal ) 
{ 
    BITMAPbm; 
    BITMAPINFOHEADERbi; 
    LPBITMAPINFOHEADER lpbi; 
    DWORDdwLen; 
    HANDLEhDIB; 
    HANDLEhandle; 
    HDC hDC; 
    HPALETTEhPal; 
  
  
    ASSERT( bitmap.GetSafeHandle() ); 
  
    // The function has no arg for bitfields 
    if( dwCompression == BI_BITFIELDS ) 
        return NULL; 
  
    // If a palette has not been supplied use defaul palette 
    hPal = (HPALETTE) pPal->GetSafeHandle(); 
    if (hPal==NULL) 
        hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE); 
  
    // Get bitmap information 
    bitmap.GetObject(sizeof(bm),(LPSTR)&bm); 
  
    // Initialize the bitmapinfoheader 
    bi.biSize= sizeof(BITMAPINFOHEADER); 
    bi.biWidth= bm.bmWidth; 
    bi.biHeight = bm.bmHeight; 
    bi.biPlanes = 1; 
    bi.biBitCount= bm.bmPlanes * bm.bmBitsPixel; 
    bi.biCompression= dwCompression; 
    bi.biSizeImage= 0; 
    bi.biXPelsPerMeter= 0; 
    bi.biYPelsPerMeter= 0; 
    bi.biClrUsed= 0; 
    bi.biClrImportant= 0; 
  
    // Compute the size of the  infoheader and the color table 
    int nColors = (1 << bi.biBitCount); 
    if( nColors > 256 ) 
        nColors = 0; 
    dwLen  = bi.biSize + nColors * sizeof(RGBQUAD); 
  
    // We need a device context to get the DIB from 
    hDC = GetDC(NULL); 
    hPal = SelectPalette(hDC,hPal,FALSE); 
    RealizePalette(hDC); 
  
    // Allocate enough memory to hold bitmapinfoheader and color table 
    hDIB = GlobalAlloc(GMEM_FIXED,dwLen); 
  
    if (!hDIB) 
    { 
        SelectPalette(hDC,hPal,FALSE); 
        ReleaseDC(NULL,hDC); 
        return NULL; 
    } 
  
    lpbi = (LPBITMAPINFOHEADER)hDIB; 
  
    *lpbi = bi; 
  
    // Call GetDIBits with a NULL lpBits param, so the device driver  
    // will calculate the biSizeImage field  
    GetDIBits(hDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight, 
        (LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS); 
  
    bi = *lpbi; 
  
    // If the driver did not fill in the biSizeImage field, then compute it 
    // Each scan line of the image is aligned on a DWORD (32bit) boundary 
    if (bi.biSizeImage == 0){ 
        bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8) 
            * bi.biHeight; 
  
        // If a compression scheme is used the result may infact be larger 
        // Increase the size to account for this. 
        if (dwCompression != BI_RGB) 
            bi.biSizeImage = (bi.biSizeImage * 3) / 2; 
    } 
  
    // Realloc the buffer so that it can hold all the bits 
    dwLen += bi.biSizeImage; 
    if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE)) 
        hDIB = handle; 
    else{ 
        GlobalFree(hDIB); 
  
        // Reselect the original palette 
        SelectPalette(hDC,hPal,FALSE); 
        ReleaseDC(NULL,hDC); 
        return NULL; 
    } 
  
    // Get the bitmap bits 
    lpbi = (LPBITMAPINFOHEADER)hDIB; 
  
    // FINALLY get the DIB 
    BOOL bGotBits = GetDIBits( hDC, (HBITMAP)bitmap.GetSafeHandle(), 
        0L,// Start scan line 
        (DWORD)bi.biHeight,// # of scan lines 
        (LPBYTE)lpbi // address for bitmap bits 
        + (bi.biSize + nColors * sizeof(RGBQUAD)), 
        (LPBITMAPINFO)lpbi,// address of bitmapinfo 
        (DWORD)DIB_RGB_COLORS);// Use RGB for color table 
  
    if( !bGotBits ) 
    { 
        GlobalFree(hDIB); 
  
        SelectPalette(hDC,hPal,FALSE); 
        ReleaseDC(NULL,hDC); 
        return NULL; 
    }    
    SelectPalette(hDC,hPal,FALSE); 
    ReleaseDC(NULL,hDC); 
    return hDIB; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
  
/*******************************************************************************/ 
//LPTSTR szFile : DestFile 
//HANDLE hDIB  : Handle sur un DIB (convertis depuis un CBitmap par DDBToDIB) 
/*******************************************************************************/ 
BOOL WriteDIB( LPTSTR szFile, HANDLE hDIB) 
{ 
BITMAPFILEHEADERhdr; 
LPBITMAPINFOHEADERlpbi; 
  
if (!hDIB) 
return FALSE; 
  
CFile file; 
if( !file.Open( szFile, CFile::modeWrite|CFile::modeCreate) ) 
return FALSE; 
  
lpbi = (LPBITMAPINFOHEADER)hDIB; 
  
int nColors = 1 << lpbi->biBitCount; 
  
// Fill in the fields of the file header  
hdr.bfType= ((WORD) ('M' << 8) | 'B');// is always "BM" 
hdr.bfSize= GlobalSize (hDIB) + sizeof( hdr ); 
hdr.bfReserved1 = 0; 
hdr.bfReserved2 = 0; 
hdr.bfOffBits= (DWORD) (sizeof( hdr ) + lpbi->biSize + 
nColors * sizeof(RGBQUAD)); 
  
// Write the file header  
file.Write( &hdr, sizeof(hdr) ); 
  
// Write the DIB header and the bits  
file.Write( lpbi, GlobalSize(hDIB) ); 
  
file.Close(); 
  
return TRUE; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
  
HINSTANCEhIn= NULL; 
HRSRCSrc= NULL; 
HGLOBAL hMem= NULL; 
DWORD rsize= NULL; 
CStringRSNumb; 
  
RSNumb.Format("#%d",IDR_RESOURCE_BINAIRE); 
  
hIn= ::AfxGetResourceHandle(); 
//ou BINARY est un Dossier dans l'onglet resource (Comme Dilalog) 
//à l'import d'une resource binaire, il demande le resource Type 
//c'est en fait le nom qu'il va donner au dossier 
tSrc= ::FindResource(hIn,RSNumb.GetBuffer(0),"BINARY"); 
rsize= ::SizeofResource(hModule,hRes); 
hMem= ::LoadResource(hModule,hRes); 
if (hMem) 
{ 
    BYTE *pData = (BYTE *) ::LockResource(hMem); 
    if (pData) 
    { 
        //travaille avec la resource 
    } 
} 
else  
{ 
    AfxmessageBox("Unable to load resource!"); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
WORD   B,G,R; 
     //Application du masque pour retirer les 3 bits de poids faible 
     //Dans le cas du 16 bits le masque pour le vert est 0xFC 
   B = BuffBGR[Ind  ] & 0xF8; 
   G = BuffBGR[Ind+1] & 0xF8; 
   R = BuffBGR[Ind+2] & 0xF8; 
  
    //application des décalages 
   B = (B>>3); 
   G = (G<<2); 
   R = (R<<7); 
  
    //composition des valeurs 
   WORD BGR16Bit = (R + G + B); 
  
    //Et swap entre le byte de poids fort et de poids faible. 
   BGR16Bit = (BGR16Bit << 8) + (BGR16Bit >> 8);

1
2
CImageList ImageList;// attention l'objet ne doit pas etre locale a une fonction 
ImageList.Attach(ImageList_LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP1), 35, 1, RGB(255, 0, 255)));

1
2
3
4
5
6
7
8
9
10
11
12
  
CBitmap Bmp;  
CImage Image;  
int         i;  
  
Bmp.LoadBitmap(IDB_MON_IMAGE); // image 100x16 en couleur vraie Windows  
Image.Attach(Bmp, Image.DIBOR_DEFAULT);  
  
for(int i=0; i<16;i++)  
{  
  Image.SetPixel(99,i,RGB(0,0,0));  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
  
/*******************************************************************************/ 
// par Zafir Anjum  http://www.codeguru.com/Cpp/G-M/bitmap/article.php/c1741 
// WriteWindowToDIB par Zafir Anjum  
// LPTSTR DestFile 
// Pointeur sur un CWnd 
/*******************************************************************************/ 
BOOL WriteWindowToDIB( LPTSTR szFile, CWnd *pWnd ) 
{ 
    CBitmap bitmap; 
    CWindowDCdc(pWnd); 
    CDC memDC; 
    CRectrect; 
  
    memDC.CreateCompatibleDC(&dc); 
    pWnd->GetWindowRect(rect); 
  
    bitmap.CreateCompatibleBitmap(&dc, rect.Width(),rect.Height() ); 
  
    CBitmap* pOldBitmap = memDC.SelectObject(&bitmap); 
    memDC.BitBlt(0, 0, rect.Width(),rect.Height(), &dc, 0, 0, SRCCOPY); 
  
    // Create logical palette if device support a palette 
    CPalette pal; 
    if( dc.GetDeviceCaps(RASTERCAPS) & RC_PALETTE ) 
    { 
        UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256); 
        LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize]; 
        pLP->palVersion = 0x300; 
  
        pLP->palNumEntries = 
            GetSystemPaletteEntries( dc, 0, 255, pLP->palPalEntry ); 
  
        // Create the palette 
        pal.CreatePalette( pLP ); 
  
        delete[] pLP; 
    } 
    memDC.SelectObject(pOldBitmap); 
  
    // Convert the bitmap to a DIB 
    HANDLE hDIB = DDBToDIB( bitmap, BI_RGB, &pal );     
    if( hDIB == NULL )return FALSE; 
  
    // Write it to file 
    WriteDIB( szFile, hDIB );    
    // Free the memory allocated by DDBToDIB for the DIB 
    GlobalFree( hDIB ); 
    return TRUE; 
}

1
2
if(!static_cast<HBITMAP>(m_bitmap)) 
     m_bitmap.CreateCompatibleBitmap( dc, rcClient.Width(), rcClient.Height() );