Bitmap_Win32.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/

namespace cmlabs {


//////////////////////////////////////////////////////////////////////
// Win32 Drawing Routines
//////////////////////////////////////////////////////////////////////

bool Bitmap::drawOn(HDC hdc, int x, int y, int w, int h) {

        if (data == NULL)
                return false;

        ObjectCollection* col = (ObjectCollection*) aux;
        if (col == NULL)
                return true;

        int byteWidth = width*4;

        int iSize = sizeof(BITMAPINFO) + 2 * sizeof(RGBQUAD);
        BITMAPINFO* bInfo = (BITMAPINFO*) malloc(iSize);
        memset(bInfo, 0, iSize);

        bInfo->bmiHeader.biSize = iSize;
        bInfo->bmiHeader.biWidth = width;
        bInfo->bmiHeader.biHeight = -1 * height;
        bInfo->bmiHeader.biPlanes = 1;
//      bInfo->bmiHeader.biBitCount = 24; // depth;
        bInfo->bmiHeader.biBitCount = 32; // depth;
//      bInfo->bmiHeader.biSizeImage = height * width * 3; // size;
        bInfo->bmiHeader.biSizeImage = height * width * 4; // size;
        bInfo->bmiHeader.biXPelsPerMeter = 0;
        bInfo->bmiHeader.biYPelsPerMeter = 0;
        bInfo->bmiHeader.biClrUsed = 0;
        bInfo->bmiHeader.biClrImportant = 0;
//      bInfo->bmiHeader.biCompression = BI_RGB;
        bInfo->bmiHeader.biCompression = BI_BITFIELDS;
        bInfo->bmiColors[0].rgbBlue = 0xff;
        bInfo->bmiColors[1].rgbGreen = 0xff;
        bInfo->bmiColors[2].rgbRed = 0xff;

#ifdef WIN32_POCKETPC

        // Use SetDIBitsToDevice for non-stretch...
        SetDIBitsToDevice(hdc, 
                x,y,w,h,  // screen coordinates
                0,0,0,height,  // bitmap coordinates
                data, bInfo, DIB_RGB_COLORS);

#else

        Box* box;
        int n = col->getCount();
        if (n > 0) {
                int xx, yy, ww, hh;
                for (int i=0; i<n; i++) {
                        if ( (box = (Box*) col->get(i)) != NULL) {
                                xx = (int)box->getLeftX();
                                yy = (int)box->getUpperY();
                                ww = (int)box->getWidth();
                                hh = (int)box->getHeight();
                                // Use SetDIBitsToDevice for non-stretch...
                                SetDIBitsToDevice(hdc, 
                                        x+xx, y+yy, ww, hh,  // screen coordinates
                                        xx,height-yy-hh,0,height,  // bitmap coordinates
                                        data, bInfo, DIB_RGB_COLORS);
                        }
                }
        }
        else {
                // Use SetDIBitsToDevice for non-stretch...
                SetDIBitsToDevice(hdc, 
                        x,y,w,h,  // screen coordinates
                        0,0,0,height,  // bitmap coordinates
                        data, bInfo, DIB_RGB_COLORS);
        }

#endif



/*      StretchDIBits(hdc,
                0,0,width,height,  // screen coordinates
                0,0,width,height,  // bitmap coordinates
                data, bInfo, DIB_RGB_COLORS, SRCCOPY);
*/
        free(bInfo);

/*      if (hBitmap == NULL)
                return false;

        JTime t1;
        HDC paintDC = CreateCompatibleDC(0);
        JTime t2;

        SelectObject(paintDC, hBitmap);
        JTime t3;
        if ( (w > 0) && (h > 0) )
                BitBlt(hdc, x, y, w, h, paintDC, 0, 0, SRCCOPY);
        else
                BitBlt(hdc, x, y, width, height, paintDC, 0, 0, SRCCOPY);
        JTime t4;
        DeleteDC(paintDC);
        JTime t5;

        JString str = JString::format("%d   %d   %d   %d", t2 - t1, t3 - t2, t4 - t3, t5 - t4);
*/
        return true;
}

/*
char* Bitmap::createHBitmap() {
        
        if (data != NULL)
                return false;

        int iSize = sizeof(BITMAPINFO) + 2 * sizeof(RGBQUAD);
        BITMAPINFO* bInfo = (BITMAPINFO*) malloc(iSize);
        memset(bInfo, 0, iSize);

        bInfo->bmiHeader.biSize = iSize;
        bInfo->bmiHeader.biWidth = width;
        bInfo->bmiHeader.biHeight = -1 * height;
        bInfo->bmiHeader.biPlanes = planes;
        bInfo->bmiHeader.biBitCount = 32; // depth;
        bInfo->bmiHeader.biSizeImage = height * width * 4; // size;
        bInfo->bmiHeader.biXPelsPerMeter = 0;
        bInfo->bmiHeader.biYPelsPerMeter = 0;
        bInfo->bmiHeader.biClrUsed = 0;
        bInfo->bmiHeader.biClrImportant = 0;
        bInfo->bmiHeader.biBitCount = 32; // depth;
        bInfo->bmiHeader.biCompression = BI_BITFIELDS;
        bInfo->bmiColors[0].rgbBlue = 0xff;
        bInfo->bmiColors[1].rgbGreen = 0xff;
        bInfo->bmiColors[2].rgbRed = 0xff;

        void* hBitmapData;
        HDC fakeDC = CreateCompatibleDC(0);
        hBitmap = CreateDIBSection(fakeDC, bInfo, DIB_RGB_COLORS, &hBitmapData, NULL, 0);
        DeleteDC(fakeDC);

        free(bInfo);

        if (hBitmap == NULL) {
                return NULL;
        }

        return (char*) hBitmapData;

//      if (hBitmapChanged) {

//              memcpy((char*) hBitmapData, data, byteWidth*height);

//              char* hdata = (char*) hBitmapData;
//              char* dst = hdata + (height-1) * byteWidth;
//              char* dst = hdata;
//              char* src = data;

//              memcpy(dst, src, byteWidth*height);


                // memcpy(dst, src, byteWidth*height);

                        
//                      memcpy(dst, src, byteWidth);
//                      src += byteWidth;
//                      dst += byteWidth;
//              }

//              hBitmapChanged = false;
//      }

//      return true;
}
*/

bool Bitmap::copyFromHDC(HDC hdc, int x, int y, int w, int h) {

//      if (hBitmap == NULL)
//              return false;

//      HDC paintDC = CreateCompatibleDC(0);
//      SelectObject(paintDC, hBitmap);

//      if ( (w > 0) && (h > 0) )
//              BitBlt(paintDC, 0, 0, w, h, hdc, x, y, SRCCOPY);
//      else
//              BitBlt(paintDC, 0, 0, width, height, hdc, x, y, SRCCOPY);

//      DeleteDC(paintDC);
        return true;
}


} // namespace cmlabs

---