//*****************************************************************************
// 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));
}

}

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

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

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

CDC::StretchBlt
BOOL StretchBlt ( 
int x, 
int y, 
int nWidth, 
int nHeight, 
CDC* pSrcDC, 
int xSrc, 
int ySrc, 
int nSrcWidth, 
int nSrcHeight, 
DWORD dwRop ); 

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

    pDC->SetStretchBltMode( COLORONCOLOR );

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

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

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

HICON CWinApp::LoadIcon( UINT nIDResource ) const; 

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 ); 

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

/*******************************************************************************/
// 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;
}

/*******************************************************************************/
//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;
}

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!");
}

   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 poid fort et de poid faible.
   BGR16Bit = (BGR16Bit << 8) + (BGR16Bit >> 8); 

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)));

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

/*******************************************************************************/
// 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;
}

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