Function DessinerSur( PlancheADessin :HDC;
                      DestLargeur,
                      DestHauteur :Integer ) :Boolean;
Var
   hBMP :HBITMAP;
   MemoireDC :HDC;

Begin
      If GetObjectType( PlancheADessin ) = 0 Then
          Exit;

      hBMP := CreateCompatibleBitmap( PlancheADessin,
                                     BmpINFO.biWidth, BmpINFO.biHeight );
      If hBMP = NULL Then
          Exit;

      MemoireDC := CreateCompatibleDC( PlancheADessin );
      If MemoireDC = NULL Then
          Exit;

      If SetDIBits( MemoireDC, hBMP, 0, BmpINFO.biHeight,
                   pTabPixels, pBmpINFO^, DIB_RGB_COLORS ) <= 0 Then
         Exit;

      SelectObject( MemoireDC , hBMP );

      If StretchBlt( PlancheADessin,
                     0, 0, DestLargeur, DestHauteur,
                     MemoireDC,
                     0, 0, BmpINFO.biWidth, BmpINFO.biHeight,
                     SRCCOPY ) <> False Then
         Result := True ;

      DeleteObject( hBMP );
      DeleteDC( MemoireDC );

     End;
End;

hBMP :HBITMAP;

Handle sur un Bitmap. Genre de pointeur sur un Bitmap.

MemoireDC :HDC;

Contexte Graphique(DC). C'est par l'entremise de cette variable que nous allons créer un DC en mémoire seulement.

If GetObjectType( PlancheADessin )...;

Vérification du type de contexte graphique(DC) passé en paramètre.

hBMP := CreateCompatibleBitmap( PlancheADessin, BitMapTemp.Width, BitMapTemp.Height );

Création d'un Bitmap compatible avec le DC où nous voulons l'afficher. Supposons que nous voudrions dessiner notre Bitmap sur un DC qui ne supporte que deux couleur (Monocrome) alors le Bitmap compatible serait créer de manière à ce qu'il suporte le mode monocrome. Pas trop compliqué n'est-ce pas ?

MemoireDC := CreateCompatibleDC( PlancheADessin );

Création d'un DC compatible aussi avec notre DC où nous voulons dessiner notre Bitmap.

SetDIBits( MemoireDC, hBMP, ..., DIB_RGB_COLORS );

Cette fonction dessine le contenu d'un tableau de pixel sur un DC. Voici la description de cette fonction :

SetDIBits( hdc                    :HDC;         // DC de destination 
           hbmp                   :HBITMAP;     // Handle du Bitmap
           uStartScan,                          // Première ligne à lire dans le tableau de Pixels 
           cScanLines             :Cardinal;    // Dernière ligne à lire dans le tableau de Pixels 
           lpvBits                :Pointer;     // Pointer sur le tableau de pixels 
           Const lpbmi            :BITMAPINFO;  // Pointeur sur la Structure d'info TBitMapInfo 
           fuColorUse             :Cardinal     // Type de gestion de pixel RGB ou Indexé 
) :Integer;  
										 

SelectObject( MemoireDC , hBMP );

Liasons des deux objet créés. Donc on selectionne le Bitmap(hBMP) dans le DC en mémoire.

StretchBlt( PlancheADessin,...

Cette fonction sert à dessiner un Bitmap sur un DC passé en paramètre. Si le Bitmap à dessiner est plus large que sa destination alors cette fonction le rétréssira en revanche s'il est trop petit cette fonction l'agrandira. Description de cette fonction :

StretchBlt( hdcDest      :HDC;       // DC de destination
            nXOriginDest :Integer;   // Coordonnée X Haut-Gauche de destination
            nYOriginDest :Integer;   // Coordonnée Y Haut-Gauche de destination
            nWidthDest   :Integer;   // Largeur de la destination
            nHeighDest   :Integer;   // Hauteur de la destination
            hdcSrc       :HDC;       // DC de la source
            nXOriginSrc  :Integer;   // Coordonnée X Haut-Gauche de l'origine 
            nYOriginSrc  :Integer;   // Coordonnée Y Haut-Gauche de l'origine
            nWidthSrc    :Integer;   // Largeur de l'origine
            nHeightSrc   :Integer;   // Hauteur de l'origine
            dwRop        :DWORD;     // Type de traitement
): Boolean;			

DeleteObject( hBMP );

Très important quand nous avons fini d'utiliser un objet il faut libérer la mémoire prise par celui-ci.

DeleteDC( MemoireDC );

Encore plus important quand on à plus besion d'un DC il faut absolument le détruire si on ne veut pas avoir de surprises avec Windows.

Procedure InverserCouleur;
Var
   LongeurDuneLigne :Integer;    {Longeur d'une ligne de pixel en octets}
   Parcours         :Integer;    {Ligne parcourue (Partant du bas du bitmap)}
   X                :Integer;    {Parcourir chaque octet d'une ligne de pixels}

   PointeurTemp     :Pointer;    {Pointeur temporaire sur les pixels du Bitmap}
   CouleurIndex     :Integer;    {Incrémenteur pour parcourir la palette}
begin
     Case BmpINFO.biBitCount Of

     1, 4, 8 :
         Begin
              For CouleurIndex := 0 To PalNbCouleurs - 1 Do
              Begin
                   PointeurTemp := Pointer( Integer(PtrDebutPal) + CouleurIndex * SizeOf(TRGBQuad));
                   TRGBQuad(PointeurTemp^).rgbRed    := Not TRGBQuad(PointeurTemp^).rgbRed;
                   TRGBQuad(PointeurTemp^).rgbGreen  := Not TRGBQuad(PointeurTemp^).rgbGreen;
                   TRGBQuad(PointeurTemp^).rgbBlue   := Not TRGBQuad(PointeurTemp^).rgbBlue;
              End;
         End;


		 
          16 :
         Begin
              LongeurDuneLigne := ((( BmpINFO.biWidth * BmpINFO.biBitCount ) + 31) And -31) Shr 3;
              Parcours     := 0;

              While Parcours < LongeurDuneLigne * (BmpINFO.biHeight - 1) Do
              Begin
                   For X := 0 To LongeurDuneLigne - 1 Do
                   Begin
                        PointeurTemp := Pointer(Integer(pTabPixels) + Parcours + X );
                        Byte( PointeurTemp^ ) := Not Byte( PointeurTemp^ );
                   End;
                   Inc(Parcours, LongeurDuneLigne );
              End;
         End;


		 
          24 :
         Begin
              For X := 0 To (BmpINFO.biHeight * BmpINFO.biWidth) Do
              Begin
                   PointeurTemp := Pointer( Integer(pTabPixels) + X * SizeOf(TRGBTriple) );

                   TRGBTriple( PointeurTemp^ ).rgbtBlue  := Not TRGBTriple( PointeurTemp^ ).rgbtBlue;
                   TRGBTriple( PointeurTemp^ ).rgbtGreen := Not TRGBTriple( PointeurTemp^ ).rgbtGreen;
                   TRGBTriple( PointeurTemp^ ).rgbtRed   := Not TRGBTriple( PointeurTemp^ ).rgbtRed;
              End;
         End;

		 
          32 :
         Begin
              For X := 0 To (BmpINFO.biHeight * BmpINFO.biWidth) Do
              Begin
                   PointeurTemp := Pointer( Integer(pTabPixels) + X * SizeOf(TRGBQuad));

                   TRGBQuad( PointeurTemp^ ).rgbBlue  := Not TRGBQuad( PointeurTemp^ ).rgbBlue;
                   TRGBQuad( PointeurTemp^ ).rgbGreen := Not TRGBQuad( PointeurTemp^ ).rgbGreen;
                   TRGBQuad( PointeurTemp^ ).rgbRed   := Not TRGBQuad( PointeurTemp^ ).rgbRed;
              End;
         End;

     End;
end;

Petit trucs :

Byte  

Utile pour travailler sur des bitmap ayant 1, 4, 8 bpp.

Dword  

Gérer des bitmaps ayant 16bpp, parce qu'un pixel à besion de deux octets alors on récupère deux octets DWORD = 2 octets.

TRGBTRIPLE

Utile sur les 24bpp, 3 octets pour 1 pixels.

TRGBQUAD

Utile sur les 32bpp, 4 octets pour 1 pixels et dont un qui sert complètement à rien.

• Chargement d'un bitmap.
• Afficher la palette du bitmap.
• Renverser l'image (Horizontal ou vertical).
• Ajustement des couleurs Rouge, Vert et bleu selon un pourcentage.
• Griser une image (GrayScale).
• Inverser toutes les couleurs d'un bitmap.
• Récupérer les informations en rapport avec le Bitmap.
• Possibilité de charger ou enregistrer la palette du Bitmap.
• Conversion

  1bpp à 24bpp
  4bpp à 24bpp
  8bpp à 24bpp
  16bpp à 24bpp
  32pp à 24bpp
  
  1bpp à 32bpp avec valeur Alpha
  4bpp à 32bpp avec valeur Alpha
  8bpp à 32bpp avec valeur Alpha
  16bpp à 32bpp avec valeur Alpha
  24pp à 32bpp avec valeur Alpha
  

• Eregistrement sous le format courant.