Bitmap est une Classe
hérite de Image
FIN

Procedure Constructeur(nWidth est un entier = 0, nHeight est un entier = 0, format est un entier = PixelFormat32bppARGB)

nPtr est un entier système

SI MesParamètres..NbReçus > 0 ALORS

// Crée l'objet
GdipCreateBitmapFromScan0(nWidth, nHeight, 0, format, Null, &nPtr)
FIN

// Appel du constructeur ancêtre
Image.Constructeur(nPtr)

Procedure Histogram()

stHistogram est un HistogramData
nCount est un entier

// Lecture de la propriété (1)
GdipBitmapGetHistogramSize(Pointer, &nCount)

Dimension(stHistogram.channel0, nCount)
Dimension(stHistogram.channel1, nCount)
Dimension(stHistogram.channel2, nCount)
Dimension(stHistogram.channel0, nCount)

// Lecture de la propriété (2)
GdipBitmapGetHistogram(Pointer, HistogramFormatARGB, nCount, &stHistogram.channel0, &stHistogram.channel1, &stHistogram.channel2, &stHistogram.channel3)

RENVOYER stHistogram

Procedure PRIVÉE Histogram(v <utile>)

// Résumé : FromImage
Procedure GLOBALE FromImage(pclimage est un Image dynamique)

pclObjet est un Bitmap dynamique = allouer un Bitmap(pclimage.Width, pclimage.Height, pclimage.PixelFormat)
// g est un graphics = graphics.FromImage(pclObjet)

// Crée l'objet
// g.DrawImage(pclimage, 0, 0, pclimage.width, pclimage.height)
// g.Dispose()

RENVOYER pclObjet

// Résumé : FromFile
Procedure GLOBALE fromFile(filename est une chaîne, bICM est un booléen = Faux)

nPtr est un entier système
pclObjet est un Bitmap dynamique = allouer un Bitmap
u est une chaîne UNICODE = filename


SI bICM ALORS

// Crée l'objet
GdipCreateBitmapFromFileICM(&u, &nPtr)
SINON

// Crée l'objet
GdipCreateBitmapFromFile(&u, &nPtr)
FIN

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

// Résumé : FromFile
Procedure GLOBALE FromMemory(buffer est un Buffer, bICM est un booléen = Faux)

nPtr est un entier système
pclObjet est un Bitmap dynamique = allouer un Bitmap
nPtrStream est un entier système
nPtrGlobal est un entier système

// Crée un pointeur mémoire
nPtrGlobal = API("kernel32", "GlobalAlloc", 0x0040, Taille(buffer))
Transfert(nPtrGlobal, &buffer, Taille(buffer))

// Crée un IStream sur le pointeur mémoire
API("ole32", "CreateStreamOnHGlobal", nPtrGlobal, Vrai, &nPtrStream)

// Crée l'objet
SI bICM ALORS
GdipCreateBitmapFromStreamICM(nPtrStream, &nPtr)
SINON
GdipCreateBitmapFromStream(nPtrStream, &nPtr)
FIN

// Libère le IStream
AppelInterface(nPtrStream, 2)

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

// Résumé : FromScan0
Procedure GLOBALE FromScan0(nWidth est un entier, nHeight est un entier, stride est un entier, format est un entier, buffer est un entier système)

nPtr est un entier système
pclObjet est un Bitmap dynamique = allouer un Bitmap

// Crée l'objet
GdipCreateBitmapFromScan0(nWidth, nHeight, stride, format, buffer, &nPtr)

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

// Résumé : GetPixel
Procedure GetPixel(x est un entier, y est un entier)

argb est un entier
pclColor est un Color dynamique = allouer un Color

// Lecture de la propriété
GdipBitmapGetPixel(Pointer, x, y, &argb)

// Allocation
pclColor.Value = argb

RENVOYER pclColor

// Résumé : SetPixel
Procedure SetPixel(x est un entier, y est un entier, Color est un Color)

// Ecriture de la propriété
GdipBitmapSetPixel(Pointer, x, y, Color.Value)

// Résumé : FromHicon
Procedure GLOBALE FromHicon(hicon est un entier système)

nPtr est un entier système
pclObjet est un Bitmap dynamique = allouer un Bitmap

// Crée l'objet
GdipCreateBitmapFromHICON(hicon, &nPtr)

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

// Résumé : FromResource
Procedure GLOBALE FromResource(hinstance est un entier système, bitmapName est une chaîne)

nPtr est un entier système
u est une chaîne UNICODE = bitmapName
pclObjet est un Bitmap dynamique = allouer un Bitmap

// Crée l'objet
GdipCreateBitmapFromResource(hinstance, &bitmapName, &nPtr)

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

// Résumé : GetHicon
Procedure GetHicon()

nHIco est un entier système

// Lecture de la propriété
GdipCreateHICONFromBitmap(Pointer, &nHIco)

RENVOYER nHIco

// Résumé : LockBits
Procedure LockBits(rect est un RECT, flags est un entier, format est un entier)

st est un BitmapData
GdipBitmapLockBits(Pointer, &rect, flags, format, &st)

RENVOYER st

// Résumé : MakeTransparent
Procedure MakeTransparent(transpColor est un Color dynamique = GetPixel(0, 0))

pclBmp est un Bitmap dynamique = allouer un Bitmap(Width, Height, PixelFormat32bppARGB)
g est un Graphics dynamique = Graphics.FromImage(pclBmp)
dstRect est un RECT = [0, 0, Width, Height]
imgAtt est un ImageAttributes dynamique = allouer un ImageAttributes

// Couleur
imgAtt.SetColorKey(transpColor, transpColor)
g.DrawImage(objet, 0, 0, Width, Height, dstRect.X, dstRect.Y, dstRect.Width, dstRect.Height, UnitPixel, imgAtt)

// Echange les pointeurs
Pointer <=> pclBmp.Pointer

g.Dispose()
pclBmp.Dispose()
imgAtt.Dispose()

// Résumé : SetResolution
Procedure SetResolution(x est un réel sur 4, y est un réel sur 4)

// Ecriture de la propriété
GdipBitmapSetResolution(Pointer, x, y)

// Résumé : UnlockBits
Procedure UnlockBits(bdata est un BitmapData)

GdipBitmapUnlockBits(Pointer, &bdata)

// Résumé : ApplyEffect
Procedure ApplyEffect(Effect est un Effect dynamique, RECT est un RECT dynamique = Null)

GdipBitmapApplyEffect(Pointer, Effect.Pointer, (RECT = Null ? Null SINON RECT), Faux, Null, Null)

// Résumé : FromFile
Procedure GLOBALE fromURL(sURL est une chaîne, bICM est un booléen = Faux)

nPtr est un entier système
pclObjet est un Bitmap dynamique = allouer un Bitmap
nPtrStream est un entier système
nPtrGlobal est un entier système
buffer est un Buffer

// Exécution de la requête
HTTPRequête(sURL)
buffer = HTTPDonneRésultat(httpRésultat)

// Crée un pointeur mémoire
nPtrGlobal = API("kernel32", "GlobalAlloc", 0x0040, Taille(buffer))
Transfert(nPtrGlobal, &buffer, Taille(buffer))

// Crée un IStream sur le pointeur mémoire
API("ole32", "CreateStreamOnHGlobal", nPtrGlobal, Vrai, &nPtrStream)

// Crée l'objet
SI bICM ALORS
GdipCreateBitmapFromStreamICM(nPtrStream, &nPtr)
SINON
GdipCreateBitmapFromStream(nPtrStream, &nPtr)
FIN

// Libère le IStream
AppelInterface(nPtrStream, 2)

// Allocation
pclObjet.Pointer = nPtr

RENVOYER pclObjet

{-# LINE 1 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
-----------------------------------------------------------------------------
{-# LINE 2 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
-- |
-- Module : Graphics.Win32.GDI.Bitmap
-- Copyright : (c) Alastair Reid, 1997-2003
-- License : BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer : Esa Ilari Vuokko <ei@vuokko.info>
-- Stability : provisional
-- Portability : portable
--
-- A collection of FFI declarations for interfacing with Win32.
--
-----------------------------------------------------------------------------

module Graphics.Win32.GDI.Bitmap(
RasterOp3,
RasterOp4,
sRCCOPY,
sRCPAINT,
sRCAND,
sRCINVERT,
sRCERASE,
nOTSRCCOPY,
nOTSRCERASE,
mERGECOPY,
mERGEPAINT,
pATCOPY,
pATPAINT,
pATINVERT,
dSTINVERT,
bLACKNESS,
wHITENESS,

mAKEROP4,

BITMAP,
LPBITMAP,
setBITMAP,
deleteBitmap,
createCompatibleBitmap,
createBitmap,
createBitmapIndirect,
createDIBPatternBrushPt,
getBitmapDimensionEx,
setBitmapDimensionEx,
getBitmapInfo,

BitmapCompression,
bI_RGB,
bI_RLE8,
bI_RLE4,
bI_BITFIELDS,

ColorFormat,
dIB_PAL_COLORS,
dIB_RGB_COLORS,

LPBITMAPINFO,
BITMAPINFOHEADER,
LPBITMAPINFOHEADER,
getBITMAPINFOHEADER_,

BITMAPFILEHEADER,
LPBITMAPFILEHEADER,
getBITMAPFILEHEADER,

sizeofBITMAP,
sizeofBITMAPINFO,
sizeofBITMAPINFOHEADER,
sizeofBITMAPFILEHEADER,
sizeofLPBITMAPFILEHEADER,

createBMPFile,
cBM_INIT,
getDIBits,
setDIBits,
createDIBitmap

) WHERE

import System.Win32.Types
import Graphics.Win32.GDI.Types

import Control.Monad (liftM)
import Foreign
import Foreign.C


{-# LINE 89 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

{-# LINE 90 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

----------------------------------------------------------------
-- Resources
----------------------------------------------------------------

-- Yoiks - name clash
-- %dis bitmap x = ptr ({LPTSTR} x)
--
-- type Bitmap = LPCTSTR
--
-- intToBitmap :: Int -> Bitmap
-- intToBitmap i = makeIntResource (toWord i)
--
-- %fun LoadBitmap :: MbHINSTANCE -> Bitmap -> IO HBITMAP
-- %fail { res1 == 0 } { ErrorString("LoadBitmap") }
--
-- %const Bitmap
-- % [ OBM_CLOSE = { MAKEINTRESOURCE(OBM_CLOSE) }
-- % , OBM_UPARROW = { MAKEINTRESOURCE(OBM_UPARROW) }
-- % , OBM_DNARROW = { MAKEINTRESOURCE(OBM_DNARROW) }
-- % , OBM_RGARROW = { MAKEINTRESOURCE(OBM_RGARROW) }
-- % , OBM_LFARROW = { MAKEINTRESOURCE(OBM_LFARROW) }
-- % , OBM_REDUCE = { MAKEINTRESOURCE(OBM_REDUCE) }
-- % , OBM_ZOOM = { MAKEINTRESOURCE(OBM_ZOOM) }
-- % , OBM_RESTORE = { MAKEINTRESOURCE(OBM_RESTORE) }
-- % , OBM_REDUCED = { MAKEINTRESOURCE(OBM_REDUCED) }
-- % , OBM_ZOOMD = { MAKEINTRESOURCE(OBM_ZOOMD) }
-- % , OBM_RESTORED = { MAKEINTRESOURCE(OBM_RESTORED) }
-- % , OBM_UPARROWD = { MAKEINTRESOURCE(OBM_UPARROWD) }
-- % , OBM_DNARROWD = { MAKEINTRESOURCE(OBM_DNARROWD) }
-- % , OBM_RGARROWD = { MAKEINTRESOURCE(OBM_RGARROWD) }
-- % , OBM_LFARROWD = { MAKEINTRESOURCE(OBM_LFARROWD) }
-- % , OBM_MNARROW = { MAKEINTRESOURCE(OBM_MNARROW) }
-- % , OBM_COMBO = { MAKEINTRESOURCE(OBM_COMBO) }
-- % , OBM_UPARROWI = { MAKEINTRESOURCE(OBM_UPARROWI) }
-- % , OBM_DNARROWI = { MAKEINTRESOURCE(OBM_DNARROWI) }
-- % , OBM_RGARROWI = { MAKEINTRESOURCE(OBM_RGARROWI) }
-- % , OBM_LFARROWI = { MAKEINTRESOURCE(OBM_LFARROWI) }
-- % , OBM_OLD_CLOSE = { MAKEINTRESOURCE(OBM_OLD_CLOSE) }
-- % , OBM_SIZE = { MAKEINTRESOURCE(OBM_SIZE) }
-- % , OBM_OLD_UPARROW = { MAKEINTRESOURCE(OBM_OLD_UPARROW) }
-- % , OBM_OLD_DNARROW = { MAKEINTRESOURCE(OBM_OLD_DNARROW) }
-- % , OBM_OLD_RGARROW = { MAKEINTRESOURCE(OBM_OLD_RGARROW) }
-- % , OBM_OLD_LFARROW = { MAKEINTRESOURCE(OBM_OLD_LFARROW) }
-- % , OBM_BTSIZE = { MAKEINTRESOURCE(OBM_BTSIZE) }
-- % , OBM_CHECK = { MAKEINTRESOURCE(OBM_CHECK) }
-- % , OBM_CHECKBOXES = { MAKEINTRESOURCE(OBM_CHECKBOXES) }
-- % , OBM_BTNCORNERS = { MAKEINTRESOURCE(OBM_BTNCORNERS) }
-- % , OBM_OLD_REDUCE = { MAKEINTRESOURCE(OBM_OLD_REDUCE) }
-- % , OBM_OLD_ZOOM = { MAKEINTRESOURCE(OBM_OLD_ZOOM) }
-- % , OBM_OLD_RESTORE = { MAKEINTRESOURCE(OBM_OLD_RESTORE) }
-- % ]

----------------------------------------------------------------
-- Raster Ops
----------------------------------------------------------------

sRCCOPY :: RasterOp3
sRCCOPY = 13369376
sRCPAINT :: RasterOp3
sRCPAINT = 15597702
sRCAND :: RasterOp3
sRCAND = 8913094
sRCINVERT :: RasterOp3
sRCINVERT = 6684742
sRCERASE :: RasterOp3
sRCERASE = 4457256
nOTSRCCOPY :: RasterOp3
nOTSRCCOPY = 3342344
nOTSRCERASE :: RasterOp3
nOTSRCERASE = 1114278
mERGECOPY :: RasterOp3
mERGECOPY = 12583114
mERGEPAINT :: RasterOp3
mERGEPAINT = 12255782
pATCOPY :: RasterOp3
pATCOPY = 15728673
pATPAINT :: RasterOp3
pATPAINT = 16452105
pATINVERT :: RasterOp3
pATINVERT = 5898313
dSTINVERT :: RasterOp3
dSTINVERT = 5570569
bLACKNESS :: RasterOp3
bLACKNESS = 66
wHITENESS :: RasterOp3
wHITENESS = 16711778

{-# LINE 164 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

----------------------------------------------------------------
-- BITMAP
----------------------------------------------------------------

type BITMAP =
( int -- bmType
, int -- bmWidth
, int -- bmHeight
, int -- bmWidthBytes
, WORD -- bmPlanes
, WORD -- bmBitsPixel
, LPVOID -- bmBits
)

peekBITMAP :: Ptr BITMAP -> IO BITMAP
peekBITMAP p = DO
ty <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 182 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
width <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 183 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
height <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 184 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
wbytes <- (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 185 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
planes <- (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 186 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
pixel <- (\hsc_ptr -> peekByteOff hsc_ptr 18) p
{-# LINE 187 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
bits <- (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 188 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
RETURN (ty, width, height, wbytes, planes, pixel, bits)

pokeBITMAP :: Ptr BITMAP -> BITMAP -> IO ()
pokeBITMAP p (ty, width, height, wbytes, planes, pixel, bits) = DO
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p ty
{-# LINE 193 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 4) p width
{-# LINE 194 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p height
{-# LINE 195 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 12) p wbytes
{-# LINE 196 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p planes
{-# LINE 197 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 18) p pixel
{-# LINE 198 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
(\hsc_ptr -> pokeByteOff hsc_ptr 20) p bits
{-# LINE 199 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

type LPBITMAP = Ptr BITMAP

setBITMAP :: LPBITMAP -> BITMAP -> IO ()
setBITMAP = pokeBITMAP

----------------------------------------------------------------
-- Misc
----------------------------------------------------------------

deleteBitmap :: HBITMAP -> IO ()
deleteBitmap bitmap =
failIfFalse_ "DeleteBitmap" $ c_DeleteBitmap bitmap
foreign import STDCALL unsafe "windows.h DeleteObject"
c_DeleteBitmap :: HBITMAP -> IO Bool

createBitmap :: int -> int -> UINT -> UINT -> Maybe LPVOID -> IO HBITMAP
createBitmap w h planes bits mb_color_data =
failIfNull "CreateBitmap" $
c_CreateBitmap w h planes bits (maybePtr mb_color_data)
foreign import STDCALL unsafe "windows.h CreateBitmap"
c_CreateBitmap :: int -> int -> UINT -> UINT -> LPVOID -> IO HBITMAP

createBitmapIndirect :: LPBITMAP -> IO HBITMAP
createBitmapIndirect p_bm =
failIfNull "CreateBitmapIndirect" $ c_CreateBitmapIndirect p_bm
foreign import STDCALL unsafe "windows.h CreateBitmapIndirect"
c_CreateBitmapIndirect :: LPBITMAP -> IO HBITMAP

createCompatibleBitmap :: HDC -> Int32 -> Int32 -> IO HBITMAP
createCompatibleBitmap dc w h =
failIfNull "CreateCompatibleBitmap" $ c_CreateCompatibleBitmap dc w h
foreign import STDCALL unsafe "windows.h CreateCompatibleBitmap"
c_CreateCompatibleBitmap :: HDC -> Int32 -> Int32 -> IO HBITMAP

createDIBPatternBrushPt :: LPVOID -> ColorFormat -> IO HBRUSH
createDIBPatternBrushPt bm usage =
failIfNull "CreateDIBPatternBrushPt" $ c_CreateDIBPatternBrushPt bm usage
foreign import STDCALL unsafe "windows.h CreateDIBPatternBrushPt"
c_CreateDIBPatternBrushPt :: LPVOID -> ColorFormat -> IO HBRUSH

----------------------------------------------------------------
-- Querying
----------------------------------------------------------------

getBitmapDimensionEx :: HBITMAP -> IO SIZE
getBitmapDimensionEx bm =
allocaSIZE $ \ p_size -> DO
failIfFalse_ "GetBitmapDimensionEx" $ c_GetBitmapDimensionEx bm p_size
peekSIZE p_size
foreign import STDCALL unsafe "windows.h GetBitmapDimensionEx"
c_GetBitmapDimensionEx :: HBITMAP -> Ptr SIZE -> IO Bool

setBitmapDimensionEx :: HBITMAP -> SIZE -> IO SIZE
setBitmapDimensionEx bm (cx,cy) =
allocaSIZE $ \ p_size -> DO
failIfFalse_ "SetBitmapDimensionEx" $ DO
c_SetBitmapDimensionEx bm cx cy p_size
peekSIZE p_size
foreign import STDCALL unsafe "windows.h SetBitmapDimensionEx"
c_SetBitmapDimensionEx :: HBITMAP -> LONG -> LONG -> Ptr SIZE -> IO Bool

getBitmapInfo :: HBITMAP -> IO BITMAP
getBitmapInfo bm =
allocaBytes (fromIntegral sizeofBITMAP) $ \ p_bm -> DO
failIfFalse_ "GetBitmapInfo" $ c_GetBitmapInfo bm sizeofBITMAP p_bm
peekBITMAP p_bm
foreign import STDCALL unsafe "windows.h GetObjectW"
c_GetBitmapInfo :: HBITMAP -> DWORD -> LPBITMAP -> IO Bool

----------------------------------------------------------------
--
----------------------------------------------------------------

type BitmapCompression = DWORD

bI_RGB :: BitmapCompression
bI_RGB = 0
bI_RLE8 :: BitmapCompression
bI_RLE8 = 1
bI_RLE4 :: BitmapCompression
bI_RLE4 = 2
bI_BITFIELDS :: BitmapCompression
bI_BITFIELDS = 3

{-# LINE 281 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

type ColorFormat = DWORD

dIB_PAL_COLORS :: ColorFormat
dIB_PAL_COLORS = 1
dIB_RGB_COLORS :: ColorFormat
dIB_RGB_COLORS = 0

{-# LINE 288 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

----------------------------------------------------------------
-- BITMAPINFO
----------------------------------------------------------------

type LPBITMAPINFO = Ptr ()

----------------------------------------------------------------
-- BITMAPINFOHEADER
----------------------------------------------------------------

type BITMAPINFOHEADER =
( DWORD -- biSize -- sizeof(BITMAPINFOHEADER)
, LONG -- biWidth
, LONG -- biHeight
, WORD -- biPlanes
, WORD -- biBitCount -- 1, 4, 8, 16, 24 or 32
, BitmapCompression -- biCompression
, DWORD -- biSizeImage
, LONG -- biXPelsPerMeter
, LONG -- biYPelsPerMeter
, Maybe DWORD -- biClrUsed
, Maybe DWORD -- biClrImportant
)

peekBITMAPINFOHEADER :: Ptr BITMAPINFOHEADER -> IO BITMAPINFOHEADER
peekBITMAPINFOHEADER p = DO
size <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 316 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
width <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 317 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
height <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 318 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
planes <- (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 319 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
nbits <- (\hsc_ptr -> peekByteOff hsc_ptr 14) p
{-# LINE 320 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
comp <- (\hsc_ptr -> peekByteOff hsc_ptr 16) p
{-# LINE 321 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
imsize <- (\hsc_ptr -> peekByteOff hsc_ptr 20) p
{-# LINE 322 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
xDensity <- (\hsc_ptr -> peekByteOff hsc_ptr 24) p
{-# LINE 323 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
yDensity <- (\hsc_ptr -> peekByteOff hsc_ptr 28) p
{-# LINE 324 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
clrUsed <- liftM numToMaybe $ (\hsc_ptr -> peekByteOff hsc_ptr 32) p
{-# LINE 325 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
clrImp <- liftM numToMaybe $ (\hsc_ptr -> peekByteOff hsc_ptr 36) p
{-# LINE 326 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
RETURN (size, width, height, planes, nbits, comp, imsize,
xDensity, yDensity, clrUsed, clrImp)

type LPBITMAPINFOHEADER = Ptr BITMAPINFOHEADER

getBITMAPINFOHEADER_ :: LPBITMAPINFOHEADER -> IO BITMAPINFOHEADER
getBITMAPINFOHEADER_ = peekBITMAPINFOHEADER

----------------------------------------------------------------
-- BITMAPFILEHEADER
----------------------------------------------------------------

type BITMAPFILEHEADER =
( WORD -- bfType -- "BM" == 0x4d42
, DWORD -- bfSize -- number of bytes in file
, WORD -- bfReserved1 -- == 0
, WORD -- bfReserved2 -- == 0
, DWORD -- bfOffBits -- == (char*) bits - (char*) filehdr
)

peekBITMAPFILEHEADER :: Ptr BITMAPFILEHEADER -> IO BITMAPFILEHEADER
peekBITMAPFILEHEADER p = DO
ty <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 349 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
size <- (\hsc_ptr -> peekByteOff hsc_ptr 2) p
{-# LINE 350 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
res1 <- (\hsc_ptr -> peekByteOff hsc_ptr 6) p
{-# LINE 351 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
res2 <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 352 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
offset <- (\hsc_ptr -> peekByteOff hsc_ptr 10) p
{-# LINE 353 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
RETURN (ty, size, res1, res2, offset)

type LPBITMAPFILEHEADER = Ptr BITMAPFILEHEADER

getBITMAPFILEHEADER :: LPBITMAPFILEHEADER -> IO BITMAPFILEHEADER
getBITMAPFILEHEADER = peekBITMAPFILEHEADER

sizeofBITMAP :: Word32
sizeofBITMAP = (24)
{-# LINE 362 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
sizeofBITMAPINFO :: Word32
sizeofBITMAPINFO = (44)
{-# LINE 364 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
sizeofBITMAPINFOHEADER :: Word32
sizeofBITMAPINFOHEADER = (40)
{-# LINE 366 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
sizeofBITMAPFILEHEADER :: Word32
sizeofBITMAPFILEHEADER = (14)
{-# LINE 368 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}
sizeofLPBITMAPFILEHEADER :: Word32
sizeofLPBITMAPFILEHEADER = (14)
{-# LINE 370 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

----------------------------------------------------------------
-- CreateBMPFile
----------------------------------------------------------------

-- A (large) helper function - courtesy of Microsoft

createBMPFile :: string -> HBITMAP -> HDC -> IO ()
createBMPFile name bm dc =
withCString name $ \ c_name ->
c_CreateBMPFile c_name bm dc
foreign import ccall unsafe "dumpBMP.h CreateBMPFile"
c_CreateBMPFile :: LPCSTR -> HBITMAP -> HDC -> IO ()

{-# CFILES cbits/dumpBMP.c #-}

----------------------------------------------------------------
-- Device Independent Bitmaps
----------------------------------------------------------------

cBM_INIT :: DWORD
cBM_INIT = 4

{-# LINE 393 "libraries\Win32\.\Graphics\Win32\GDI\Bitmap.hsc" #-}

getDIBits :: HDC -> HBITMAP -> int -> int -> Maybe LPVOID -> LPBITMAPINFO -> ColorFormat -> IO int
getDIBits dc bm start nlines mb_bits Info usage =
failIfZero "GetDIBits" $
c_GetDIBits dc bm start nlines (maybePtr mb_bits) Info usage
foreign import STDCALL unsafe "windows.h GetDIBits"
c_GetDIBits :: HDC -> HBITMAP -> int -> int -> LPVOID -> LPBITMAPINFO -> ColorFormat -> IO int

setDIBits :: HDC -> HBITMAP -> int -> int -> LPVOID -> LPBITMAPINFO -> ColorFormat -> IO int
setDIBits dc bm start nlines bits Info Use =
failIfZero "SetDIBits" $ c_SetDIBits dc bm start nlines bits Info Use
foreign import STDCALL unsafe "windows.h SetDIBits"
c_SetDIBits :: HDC -> HBITMAP -> int -> int -> LPVOID -> LPBITMAPINFO -> ColorFormat -> IO int

createDIBitmap :: HDC -> LPBITMAPINFOHEADER -> DWORD -> LPVOID -> LPBITMAPINFO -> ColorFormat -> IO HBITMAP
createDIBitmap dc hdr option init_val Info usage =
failIfNull "CreateDIBitmap" $
c_CreateDIBitmap dc hdr option init_val Info usage
foreign import STDCALL unsafe "windows.h CreateDIBitmap"
c_CreateDIBitmap :: HDC -> LPBITMAPINFOHEADER -> DWORD -> LPVOID -> LPBITMAPINFO -> ColorFormat -> IO HBITMAP

----------------------------------------------------------------
-- End
----------------------------------------------------------------

Bitmap Bitmap (L "Texture.jpg");
width = UINT bitmap.GetWidth ();
altura UINT = bitmap.GetHeight ();
CachedBitmap CBitmap (& bitmap, e gráficos);
int j, k;
for (j = 0; j < 300; J + = 10)
para (k = 0; k <1000; k ++)
Graphics.drawImage (& bitmap, J, J / 2, largura, altura);
for (j = 0; j <300; j + = 10)
para (k = 0; k <1000; k ++)
graphics.DrawCachedBitmap (& CBitmap, J, J 150 + / 2);

CachedBitmap est une Classe
hérite de Bitmap
FIN

Procedure Constructeur(bitmap est un Bitmap dynamique = Null, g est un Graphics = Null)

nPtr est un entier système

SI MesParamètres..NbReçus = 2 ALORS
GdipCreateCachedBitmap(bitmap.Pointer, g.Pointer, &nPtr)
FIN

// Appel du constructeur ancêtre
GDIPObjet.Constructeur(nPtr)

// Résumé : Détruit l'objet
Procedure VIRTUELLE Dispose()

GdipDeleteCachedBitmap(Pointer)

// Libère l'objet
GDIPObjet.Dispose()