D:/~Research/Code/C++/EvolveTraffic/WindowToBMP.cpp

Go to the documentation of this file.

// WindowToBMP.cpp: implementation of the CWindowToBMP class.
//

#include "stdafx.h"
#include "EvolveTraffic.h"
#include "WindowToBMP.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

// Construction/Destruction

CWindowToBMP::CWindowToBMP()
{

}

CWindowToBMP::~CWindowToBMP()
{

}

bool CWindowToBMP::Write(CString file, CWnd *pWnd)
{
          char* ch = file.GetBuffer(0);
          return WriteWindowToDIB( ch, pWnd );
}

BOOL CWindowToBMP::WriteWindowToDIB( LPTSTR szFile, CWnd *pWnd )
{
        CBitmap         bitmap;
        CWindowDC       dc(pWnd);
        CDC             memDC;
        CRect           rect;

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

BOOL CWindowToBMP::WriteDIB( LPTSTR szFile, HANDLE hDIB)
{
        BITMAPFILEHEADER hdr;
        LPBITMAPINFOHEADER lpbi;

        if (!hDIB)
        return FALSE;

        CFile file;
        if (!file.Open (szFile, CFile::modeWrite | CFile::modeCreate))
        return FALSE;

        lpbi = (LPBITMAPINFOHEADER)hDIB;
        int nColors = lpbi->biBitCount;

        hdr.bfType = ((WORD) ('M' << 8) | 'B');
        hdr.bfSize = GlobalSize (hDIB) + sizeof( hdr );
        hdr.bfReserved1 = 0;
        hdr.bfReserved2 = 0;
        hdr.bfOffBits = (DWORD) (sizeof( hdr ) + sizeof(BITMAPINFOHEADER));

        file.Write( &hdr, sizeof(hdr) );
        file.Write( lpbi, GlobalSize(hDIB) );
        file.Close ();

        return TRUE;
}

HANDLE CWindowToBMP::DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal )
{
        BITMAP                  bm;
        BITMAPINFOHEADER        bi;
        LPBITMAPINFOHEADER      lpbi;
        DWORD                   dwLen;
        HANDLE                  hDIB;
        HANDLE                  handle;
        HDC                     hDC;
        HPALETTE                hPal;


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

---