if (m_hBitmap)
{
- if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
+ if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
{
wxLogLastError("GpiDeleteBitmap(hbitmap)");
}
// this function should be called from all wxBitmap ctors
void wxBitmap::Init()
{
- // m_refData = NULL; done in the base class ctor
-
- if (wxTheBitmapList)
- wxTheBitmapList->AddBitmap(this);
} // end of wxBitmap::Init
bool wxBitmap::CopyFromIconOrCursor(
wxBitmap::~wxBitmap()
{
- if (wxTheBitmapList)
- wxTheBitmapList->DeleteObject(this);
} // end of wxBitmap::~wxBitmap
wxBitmap::wxBitmap(
const char zBits[]
-, int nTheWidth
-, int nTheHeight
-, int nNoBits
+, int nWidth
+, int nHeight
+, int nDepth
)
{
Init();
HPS hPs;
DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
SIZEL vSize = {0, 0};
+ char* pzData;
wxASSERT(vHabmain != NULL);
- hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+ m_refData = pRefData;
- vHeader.cbFix = sizeof(vHeader);
- vHeader.cx = (USHORT)nTheWidth;
- vHeader.cy = (USHORT)nTheHeight;
- vHeader.cPlanes = 1L;
- vHeader.cBitCount = nNoBits;
- vHeader.ulCompression = BCA_UNCOMP;
- vHeader.cxResolution = 0;
- vHeader.cyResolution = 0;
- vHeader.cclrUsed = 0;
- vHeader.cclrImportant = 0;
- vHeader.usUnits = BRU_METRIC;
- vHeader.usRecording = BRA_BOTTOMUP;
- vHeader.usRendering = BRH_NOTHALFTONED;
- vHeader.cSize1 = 0;
- vHeader.cSize2 = 0;
- vHeader.ulColorEncoding = 0;
- vHeader.ulIdentifier = 0;
+ pRefData->m_nWidth = nWidth;
+ pRefData->m_nHeight = nHeight;
+ pRefData->m_nDepth = nDepth;
+ pRefData->m_nNumColors = 0;
+ pRefData->m_pSelectedInto = NULL;
+ hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
if (hPs == 0)
{
wxLogLastError("GpiCreatePS Failure");
}
- m_refData = pRefData;
+ if (nDepth == 1)
+ {
+ //
+ // We assume that it is in XBM format which is not quite the same as
+ // the format CreateBitmap() wants because the order of bytes in the
+ // line is inversed!
+ //
+ const size_t nBytesPerLine = (nWidth + 7) / 8;
+ const size_t nPadding = nBytesPerLine % 2;
+ const size_t nLen = nHeight * (nPadding + nBytesPerLine);
+ const char* pzSrc = zBits;
+ int nRows;
+ size_t nCols;
+
+ pzData = (char *)malloc(nLen);
+
+ char* pzDst = pzData;
+
+ for (nRows = 0; nRows < nHeight; nRows++)
+ {
+ for (nCols = 0; nCols < nBytesPerLine; nCols++)
+ {
+ unsigned char ucVal = *pzSrc++;
+ unsigned char ucReversed = 0;
+ int nBits;
- pRefData->m_nWidth = nTheWidth;
- pRefData->m_nHeight = nTheHeight;
- pRefData->m_nDepth = nNoBits;
- pRefData->m_nNumColors = 0;
- pRefData->m_pSelectedInto = NULL;
+ for (nBits = 0; nBits < 8; nBits++)
+ {
+ ucReversed <<= 1;
+ ucReversed |= (ucVal & 0x01);
+ ucVal >>= 1;
+ }
+ *pzDst++ = ucReversed;
+ }
+ if (nPadding)
+ *pzDst++ = 0;
+ }
+ }
+ else
+ {
+ //
+ // Bits should already be in Windows standard format
+ //
+ pzData = (char *)zBits; // const_cast is harmless
+ }
+
+ memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
+ vHeader.cbFix = sizeof(vHeader);
+ vHeader.cx = (USHORT)nWidth;
+ vHeader.cy = (USHORT)nHeight;
+ vHeader.cPlanes = 1L;
+ vHeader.cBitCount = nDepth;
+ vHeader.usReserved = 0;
+ vHeader.ulCompression = BCA_UNCOMP;
+ vHeader.usRecording = BRA_BOTTOMUP;
+ vHeader.usRendering = BRH_NOTHALFTONED;
+ vHeader.ulColorEncoding = BCE_RGB;
+ vHeader.ulIdentifier = 0;
+
+ memset(&vInfo, '\0', sizeof(BITMAPINFO2));
+ vInfo.cbFix = sizeof(vInfo);
+ vInfo.cx = (USHORT)nWidth;
+ vInfo.cy = (USHORT)nHeight;
+ vInfo.cPlanes = 1L;
+ vInfo.cBitCount = nDepth;
+ vInfo.usReserved = 0;
+ vInfo.ulCompression = BCA_UNCOMP;
+ vInfo.usRecording = BRA_BOTTOMUP;
+ vInfo.usRendering = BRH_NOTHALFTONED;
+ vInfo.ulColorEncoding = BCE_RGB;
+ vInfo.ulIdentifier = 0;
+
+ HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
- HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
if (!hBmp)
{
wxLogLastError("CreateBitmap");
}
+ ::WinReleasePS(hPs);
SetHBITMAP((WXHBITMAP)hBmp);
} // end of wxBitmap::wxBitmap
// wxImage-wxBitmap convertion
// ----------------------------------------------------------------------------
-bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
+bool wxBitmap::CreateFromImage (
+ const wxImage& rImage
+, int nDepth
+)
{
- wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
-
-// TODO:
-/*
- int sizeLimit = 1024*768*3;
-
- // width and height of the device-dependent bitmap
- int width = GetWidth();
- int bmpHeight = GetHeight();
-
- // calc the number of bytes per scanline and padding
- int bytePerLine = width*3;
- int sizeDWORD = sizeof( DWORD );
- int lineBoundary = bytePerLine % sizeDWORD;
- int padding = 0;
- if( lineBoundary > 0 )
+ wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+ m_refData = new wxBitmapRefData();
+
+ int nSizeLimit = 1024 * 768 * 3;
+ int nWidth = rImage.GetWidth();
+ int nBmpHeight = rImage.GetHeight();
+ int nBytePerLine = nWidth * 3;
+ int nSizeDWORD = sizeof(DWORD);
+ int nLineBoundary = nBytePerLine % nSizeDWORD;
+ int nPadding = 0;
+
+ if (nLineBoundary > 0)
{
- padding = sizeDWORD - lineBoundary;
- bytePerLine += padding;
+ nPadding = nSizeDWORD - nLineBoundary;
+ nBytePerLine += nPadding;
}
- // calc the number of DIBs and heights of DIBs
- int numDIB = 1;
- int hRemain = 0;
- int height = sizeLimit/bytePerLine;
- if( height >= bmpHeight )
- height = bmpHeight;
+
+ //
+ // Calc the number of DIBs and heights of DIBs
+ //
+ int nNumDIB = 1;
+ int nHRemain = 0;
+ int nHeight = nSizeLimit / nBytePerLine;
+
+ if (nHeight >= nBmpHeight)
+ nHeight = nBmpHeight;
else
{
- numDIB = bmpHeight / height;
- hRemain = bmpHeight % height;
- if( hRemain >0 ) numDIB++;
+ nNumDIB = nBmpHeight / nHeight;
+ nHRemain = nBmpHeight % nHeight;
+ if (nHRemain > 0)
+ nNumDIB++;
}
- // set bitmap parameters
- wxBitmap bitmap;
- wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
- bitmap.SetWidth( width );
- bitmap.SetHeight( bmpHeight );
- bitmap.SetDepth( wxDisplayDepth() );
-
- // create a DIB header
- int headersize = sizeof(BITMAPINFOHEADER);
- LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
- wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
+ //
+ // Set bitmap parameters
+ //
+ wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+ SetWidth(nWidth);
+ SetHeight(nBmpHeight);
+ if (nDepth == -1)
+ nDepth = wxDisplayDepth();
+ SetDepth(nDepth);
+
+#if wxUSE_PALETTE
+ //
+ // Copy the palette from the source image
+ //
+ SetPalette(rImage.GetPalette());
+#endif // wxUSE_PALETTE
+
+ //
+ // Create a DIB header
+ //
+ BITMAPINFOHEADER2 vHeader;
+
+ //
// Fill in the DIB header
- lpDIBh->bmiHeader.biSize = headersize;
- lpDIBh->bmiHeader.biWidth = (DWORD)width;
- lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
- lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
- // the general formula for biSizeImage:
- // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
- lpDIBh->bmiHeader.biPlanes = 1;
- lpDIBh->bmiHeader.biBitCount = 24;
- lpDIBh->bmiHeader.biCompression = BI_RGB;
- lpDIBh->bmiHeader.biClrUsed = 0;
+ //
+ memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
+ vHeader.cbFix = sizeof(vHeader);
+ vHeader.cx = (USHORT)nWidth;
+ vHeader.cy = (USHORT)nHeight;
+ vHeader.cPlanes = 1L;
+ vHeader.cBitCount = 24;
+ vHeader.ulCompression = BCA_UNCOMP;
+ vHeader.cbImage = nBytePerLine * nHeight;
+ vHeader.cclrUsed = 0;
+
+ //
// These seem not really needed for our purpose here.
- lpDIBh->bmiHeader.biClrImportant = 0;
- lpDIBh->bmiHeader.biXPelsPerMeter = 0;
- lpDIBh->bmiHeader.biYPelsPerMeter = 0;
- // memory for DIB data
- unsigned char *lpBits;
- lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
- if( !lpBits )
+ //
+ vHeader.cxResolution = 0;
+ vHeader.cyResolution = 0;
+ vHeader.cclrImportant = 0;
+ vHeader.usUnits = BRU_METRIC;
+ vHeader.usReserved = 0;
+ vHeader.cSize1 = 0;
+ vHeader.cSize2 = 0;
+ vHeader.usRecording = BRA_BOTTOMUP;
+ vHeader.usRendering = BRH_NOTHALFTONED;
+ vHeader.ulColorEncoding = BCE_RGB;
+ vHeader.ulIdentifier = 0;
+
+ //
+ // Memory for DIB data
+ //
+ unsigned char* pucBits;
+
+ pucBits = (unsigned char *)malloc(vHeader.cbImage);
+ if(!pucBits)
+ {
+ wxFAIL_MSG(wxT("could not allocate memory for DIB"));
+ return FALSE;
+ }
+
+ //
+ // Create and set the device-dependent bitmap
+ //
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ SIZEL vSize = {0, 0};
+ HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
+ HBITMAP hBmp;
+ HBITMAP hBmpOld;
+
+ hBmp = ::GpiCreateBitmap( hPS
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+ hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+#if wxUSE_PALETTE
+ HPAL hOldPalette = NULLHANDLE;
+ if (rImage.GetPalette().Ok())
{
- wxFAIL_MSG( wxT("could not allocate memory for DIB") );
- free( lpDIBh );
- return bitmap;
+ hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
}
+#endif // wxUSE_PALETTE
- // create and set the device-dependent bitmap
- HDC hdc = ::GetDC(NULL);
- HDC memdc = ::CreateCompatibleDC( hdc );
- HBITMAP hbitmap;
- hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
- ::SelectObject( memdc, hbitmap);
-
- // copy image data into DIB data and then into DDB (in a loop)
- unsigned char *data = GetData();
- int i, j, n;
- int origin = 0;
- unsigned char *ptdata = data;
- unsigned char *ptbits;
-
- for( n=0; n<numDIB; n++ )
+ //
+ // Copy image data into DIB data and then into DDB (in a loop)
+ //
+ unsigned char* pData = rImage.GetData();
+ int i;
+ int j;
+ int n;
+ int nOrigin = 0;
+ unsigned char* ptdata = pData;
+ unsigned char* ptbits;
+
+ for (n = 0; n < nNumDIB; n++)
{
- if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
+ if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
{
- // redefine height and size of the (possibly) last smaller DIB
+ //
+ // Redefine height and size of the (possibly) last smaller DIB
// memory is not reallocated
- height = hRemain;
- lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
- lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ //
+ nHeight = nHRemain;
+ vHeader.cy = (DWORD)(nHeight);
+ vHeader.cbImage = nBytePerLine * nHeight;
}
- ptbits = lpBits;
-
- for( j=0; j<height; j++ )
+ ptbits = pucBits;
+ for (j = 0; j < nHeight; j++)
{
- for( i=0; i<width; i++ )
+ for (i = 0; i < nWidth; i++)
{
- *(ptbits++) = *(ptdata+2);
- *(ptbits++) = *(ptdata+1);
- *(ptbits++) = *(ptdata );
+ *(ptbits++) = *(ptdata + 2);
+ *(ptbits++) = *(ptdata + 1);
+ *(ptbits++) = *(ptdata);
ptdata += 3;
}
- for( i=0; i< padding; i++ ) *(ptbits++) = 0;
+ for (i = 0; i < nPadding; i++)
+ *(ptbits++) = 0;
}
- ::StretchDIBits( memdc, 0, origin, width, height,\
- 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
- origin += height;
- // if numDIB = 1, lines below can also be used
- // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
- // The above line is equivalent to the following two lines.
- // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
- // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
- // or the following lines
- // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
- // HDC memdc = ::CreateCompatibleDC( hdc );
- // ::SelectObject( memdc, hbitmap);
- // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
- // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
- // ::SelectObject( memdc, 0 );
- // ::DeleteDC( memdc );
+
+ //
+ // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
+ //
+ POINTL vPoint[4] = { 0, nOrigin,
+ nWidth, nHeight,
+ 0, 0, nWidth, nHeight
+ };
+
+ ::GpiBitBlt( hPS
+ ,hPS
+ ,4
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+ nOrigin += nHeight;
}
- bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
+ SetHBITMAP((WXHBITMAP)hBmp);
+#if wxUSE_PALETTE
+ if (hOldPalette)
+ ::GpiSelectPalette(hPS, hOldPalette);
+#endif // wxUSE_PALETTE
- // similarly, created an mono-bitmap for the possible mask
- if( HasMask() )
+ //
+ // Similarly, created an mono-bitmap for the possible mask
+ //
+ if (rImage.HasMask())
{
- hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
- ::SelectObject( memdc, hbitmap);
- if( numDIB == 1 ) height = bmpHeight;
- else height = sizeLimit/bytePerLine;
- lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
- lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
- origin = 0;
- unsigned char r = GetMaskRed();
- unsigned char g = GetMaskGreen();
- unsigned char b = GetMaskBlue();
- unsigned char zero = 0, one = 255;
- ptdata = data;
- for( n=0; n<numDIB; n++ )
+ memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
+ vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ vHeader.cx = nWidth;
+ vHeader.cy = nHeight;
+ vHeader.cPlanes = 1;
+ vHeader.cBitCount = 1;
+ hBmp = ::GpiCreateBitmap( hPS
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+ hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+ if (nNumDIB == 1)
+ nHeight = nBmpHeight;
+ else
+ nHeight = nSizeLimit / nBytePerLine;
+ vHeader.cy = (DWORD)(nHeight);
+ vHeader.cbImage = nBytePerLine * nHeight;
+ nOrigin = 0;
+
+ unsigned char cRed = rImage.GetMaskRed();
+ unsigned char cGreen = rImage.GetMaskGreen();
+ unsigned char cBlue = rImage.GetMaskBlue();
+ unsigned char cZero = 0;
+ unsigned char cOne = 255;
+
+ ptdata = pData;
+ for (n = 0; n < nNumDIB; n++)
{
- if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
+ if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
{
- // redefine height and size of the (possibly) last smaller DIB
+ //
+ // Redefine height and size of the (possibly) last smaller DIB
// memory is not reallocated
- height = hRemain;
- lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
- lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ //
+ nHeight = nHRemain;
+ vHeader.cy = (DWORD)(nHeight);
+ vHeader.cbImage = nBytePerLine * nHeight;
}
- ptbits = lpBits;
- for( int j=0; j<height; j++ )
+ ptbits = pucBits;
+ for (int j = 0; j < nHeight; j++)
{
- for(i=0; i<width; i++ )
+ for (i = 0; i < nWidth; i++)
{
- if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
+ if ((*(ptdata++) != cRed) || (*(ptdata++) != cGreen) || (*(ptdata++) != cBlue))
{
- *(ptbits++) = one;
- *(ptbits++) = one;
- *(ptbits++) = one;
+ *(ptbits++) = cOne;
+ *(ptbits++) = cOne;
+ *(ptbits++) = cOne;
}
else
{
- *(ptbits++) = zero;
- *(ptbits++) = zero;
- *(ptbits++) = zero;
+ *(ptbits++) = cZero;
+ *(ptbits++) = cZero;
+ *(ptbits++) = cZero;
}
}
- for( i=0; i< padding; i++ ) *(ptbits++) = zero;
+ for (i = 0; i < nPadding; i++)
+ *(ptbits++) = cZero;
}
- ::StretchDIBits( memdc, 0, origin, width, height,\
- 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
- origin += height;
+ POINTL vPoint[4] = { 0, nOrigin,
+ nWidth, nHeight,
+ 0, 0, nWidth, nHeight
+ };
+
+ ::GpiBitBlt( hPS
+ ,hPS
+ ,4
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+ nOrigin += nHeight;
}
- // create a wxMask object
- wxMask *mask = new wxMask();
- mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
- bitmap.SetMask( mask );
- }
- // free allocated resources
- ::SelectObject( memdc, 0 );
- ::DeleteDC( memdc );
- ::ReleaseDC(NULL, hdc);
- free(lpDIBh);
- free(lpBits);
+ //
+ // Create a wxMask object
+ //
+ wxMask* pMask = new wxMask();
- // check the wxBitmap object
- if( bitmap.GetHBITMAP() )
- bitmap.SetOk( TRUE );
- else
- bitmap.SetOk( FALSE );
-*/
+ pMask->SetMaskBitmap((WXHBITMAP)hBmp);
+ SetMask(pMask);
+ hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+ }
+ //
+ // Free allocated resources
+ //
+ ::GpiSetBitmap(hPS, NULLHANDLE);
+ ::GpiDestroyPS(hPS);
+ ::DevCloseDC(hDC);
+ free(pucBits);
return TRUE;
-}
+} // end of wxBitmap::CreateFromImage
wxImage wxBitmap::ConvertToImage() const
{
- wxImage image;
+ wxImage vImage;
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
- // create an wxImage object
- int width = GetWidth();
- int height = GetHeight();
- image.Create( width, height );
- unsigned char *data = image.GetData();
- if( !data )
+ //
+ // Create an wxImage object
+ //
+ int nWidth = GetWidth();
+ int nHeight = GetHeight();
+ int nDevWidth;
+ int nDevHeight;
+ int nBytePerLine = nWidth * 3;
+ int nSizeDWORD = sizeof(DWORD);
+ int nLineBoundary = nBytePerLine % nSizeDWORD;
+ int nPadding = 0;
+ unsigned char* pData;
+ unsigned char* lpBits;
+ long lScans;
+ BITMAPINFOHEADER2 vDIBh;
+ BITMAPINFO2 vDIBInfo;
+ HDC hDCMem;
+ PSZ pszData[4] = { "Display", NULL, NULL, NULL };
+ HPS hPSMem;
+ HPS hPS;
+ SIZEL vSizlPage = {0,0};
+ HBITMAP hBitmap;
+
+ vImage.Create( nWidth
+ ,nHeight
+ );
+ pData = vImage.GetData();
+ if(!pData)
{
wxFAIL_MSG( wxT("could not allocate data for image") );
return wxNullImage;
}
-
- // calc the number of bytes per scanline and padding in the DIB
- int bytePerLine = width*3;
- int sizeDWORD = sizeof( DWORD );
- int lineBoundary = bytePerLine % sizeDWORD;
- int padding = 0;
- if( lineBoundary > 0 )
+ if(nLineBoundary > 0)
{
- padding = sizeDWORD - lineBoundary;
- bytePerLine += padding;
+ nPadding = nSizeDWORD - nLineBoundary;
+ nBytePerLine += nPadding;
}
-// TODO:
-/*
- // create a DIB header
- int headersize = sizeof(BITMAPINFOHEADER);
- LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
- if( !lpDIBh )
- {
- wxFAIL_MSG( wxT("could not allocate data for DIB header") );
- free( data );
- return;
- }
- // Fill in the DIB header
- lpDIBh->bmiHeader.biSize = headersize;
- lpDIBh->bmiHeader.biWidth = width;
- lpDIBh->bmiHeader.biHeight = -height;
- lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
- lpDIBh->bmiHeader.biPlanes = 1;
- lpDIBh->bmiHeader.biBitCount = 24;
- lpDIBh->bmiHeader.biCompression = BI_RGB;
- lpDIBh->bmiHeader.biClrUsed = 0;
- // These seem not really needed for our purpose here.
- lpDIBh->bmiHeader.biClrImportant = 0;
- lpDIBh->bmiHeader.biXPelsPerMeter = 0;
- lpDIBh->bmiHeader.biYPelsPerMeter = 0;
- // memory for DIB data
- unsigned char *lpBits;
- lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
- if( !lpBits )
+ wxDisplaySize( &nDevWidth
+ ,&nDevHeight
+ );
+ //
+ // Create and fill a DIB header
+ //
+ memset(&vDIBh, '\0', sizeof(BITMAPINFOHEADER2));
+ vDIBh.cbFix = sizeof(BITMAPINFOHEADER2);
+ vDIBh.cx = nWidth;
+ vDIBh.cy = nHeight;
+ vDIBh.cPlanes = 1;
+ vDIBh.cbImage = nBytePerLine * nHeight;
+ vDIBh.cBitCount = 24;
+
+ memset(&vDIBInfo, '\0', sizeof(BITMAPINFO2));
+ vDIBInfo.cbFix = sizeof(BITMAPINFO2);
+ vDIBInfo.cPlanes = 1;
+ vDIBInfo.cBitCount = 24;
+ vDIBInfo.ulCompression = BCA_UNCOMP;
+ vDIBInfo.usReserved = 0;
+ vDIBInfo.usRecording = BRA_BOTTOMUP;
+ vDIBInfo.usRendering = BRH_NOTHALFTONED;
+ vDIBInfo.ulColorEncoding = BCE_RGB;
+ vDIBInfo.ulIdentifier = 0;
+
+ lpBits = (unsigned char *)malloc(vDIBh.cbImage);
+ if (!lpBits)
{
- wxFAIL_MSG( wxT("could not allocate data for DIB") );
- free( data );
- free( lpDIBh );
- return;
+ wxFAIL_MSG(wxT("could not allocate data for DIB"));
+ free(pData);
+ return wxNullImage;
}
- // copy data from the device-dependent bitmap to the DIB
- HDC hdc = ::GetDC(NULL);
- HBITMAP hbitmap;
- hbitmap = (HBITMAP) bitmap.GetHBITMAP();
- ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
-
- // copy DIB data into the wxImage object
- int i, j;
- unsigned char *ptdata = data;
- unsigned char *ptbits = lpBits;
- for( i=0; i<height; i++ )
+ //
+ // Copy data from the device-dependent bitmap to the DIB
+ //
+ hDCMem = ::DevOpenDC( vHabmain
+ ,OD_MEMORY
+ ,"*"
+ ,4
+ ,(PDEVOPENDATA)pszData
+ ,NULLHANDLE
+ );
+ hPSMem = ::GpiCreatePS( vHabmain
+ ,hDCMem
+ ,&vSizlPage
+ ,PU_PELS | GPIA_ASSOC | GPIT_MICRO
+ );
+ hBitmap = ::GpiCreateBitmap( hPSMem
+ ,&vDIBh
+ ,0L
+ ,NULL
+ ,NULL
+ );
+ lScans = ::GpiQueryBitmapBits( hPSMem
+ ,0L
+ ,(LONG)nHeight
+ ,(PBYTE)lpBits
+ ,&vDIBInfo
+ );
+
+ //
+ // Copy DIB data into the wxImage object
+ //
+ int i;
+ int j;
+ unsigned char* ptdata = pData;
+ unsigned char* ptbits = lpBits;
+
+ for (i = 0; i < nHeight; i++)
{
- for( j=0; j<width; j++ )
+ for (j = 0; j < nWidth; j++)
{
*(ptdata++) = *(ptbits+2);
*(ptdata++) = *(ptbits+1);
*(ptdata++) = *(ptbits );
ptbits += 3;
}
- ptbits += padding;
+ ptbits += nPadding;
}
- // similarly, set data according to the possible mask bitmap
- if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
+ //
+ // Similarly, set data according to the possible mask bitmap
+ //
+ if (GetMask() && GetMask()->GetMaskBitmap())
{
- hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
- // memory DC created, color set, data copied, and memory DC deleted
- HDC memdc = ::CreateCompatibleDC( hdc );
- ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
- ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
- ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
- ::DeleteDC( memdc );
- // background color set to RGB(16,16,16) in consistent with wxGTK
- unsigned char r=16, g=16, b=16;
- ptdata = data;
+ hBitmap = (HBITMAP)GetMask()->GetMaskBitmap();
+
+ //
+ // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
+ //
+ HDC hMemDC = ::DevOpenDC( vHabmain
+ ,OD_MEMORY
+ ,"*"
+ ,4
+ ,(PDEVOPENDATA)pszData
+ ,NULLHANDLE
+ );
+ HPS hMemPS = ::GpiCreatePS( vHabmain
+ ,hMemDC
+ ,&vSizlPage
+ ,PU_PELS | GPIA_ASSOC | GPIT_MICRO
+ );
+ ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
+ ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
+ ::GpiQueryBitmapBits( hPSMem
+ ,0L
+ ,(LONG)nHeight
+ ,(PBYTE)lpBits
+ ,&vDIBInfo
+ );
+ ::GpiDestroyPS(hMemPS);
+ ::DevCloseDC(hMemDC);
+
+ //
+ // Background color set to RGB(16,16,16) in consistent with wxGTK
+ //
+ unsigned char ucRed = 16;
+ unsigned char ucGreen = 16;
+ unsigned char ucBlue = 16;
+
+ ptdata = pData;
ptbits = lpBits;
- for( i=0; i<height; i++ )
+ for (i = 0; i < nHeight; i++)
{
- for( j=0; j<width; j++ )
+ for (j = 0; j < nWidth; j++)
{
- if( *ptbits != 0 )
+ if (*ptbits != 0)
ptdata += 3;
else
{
- *(ptdata++) = r;
- *(ptdata++) = g;
- *(ptdata++) = b;
+ *(ptdata++) = ucRed;
+ *(ptdata++) = ucGreen;
+ *(ptdata++) = ucBlue;
}
ptbits += 3;
}
- ptbits += padding;
+ ptbits += nPadding;
}
- SetMaskColour( r, g, b );
- SetMask( TRUE );
+ vImage.SetMaskColour( ucRed
+ ,ucGreen
+ ,ucBlue
+ );
+ vImage.SetMask(TRUE);
}
else
{
- SetMask( FALSE );
+ vImage.SetMask(FALSE);
}
- // free allocated resources
- ::ReleaseDC(NULL, hdc);
- free(lpDIBh);
- free(lpBits);
-*/
-
- return image;
-}
+ //
+ // Free allocated resources
+ //
+ ::GpiDestroyPS(hPSMem);
+ ::DevCloseDC(hDCMem);
+ free(lpBits);
+ return vImage;
+} // end of wxBitmap::ConvertToImage
// ----------------------------------------------------------------------------
// sub bitmap extraction
GetBitmapData()->m_pBitmapMask = pMask;
} // end of wxBitmap::SetMask
-//
-// Will try something for OS/2 but not really sure how close
-// to the msw intent this is.
-//
wxBitmap wxBitmap::GetBitmapForDC(
wxDC& rDc
) const
{
- wxMemoryDC vMemDC;
- wxBitmap vTmpBitmap( this->GetWidth()
- ,this->GetHeight()
- ,rDc.GetDepth()
- );
- WXHBITMAP vOldBitmap;
- HPS hMemoryPS;
- HPS hPs;
- POINTL vPoint[4];
- SIZEL vSize = {0,0};
-
- hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
- hPs = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
-
- // TODO: Set the points
-
- vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
- ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
-
- return(vTmpBitmap);
+ return(*this);
} // end of wxBitmap::GetBitmapForDC
// ----------------------------------------------------------------------------
return hBmpInvMask;
} // end of WxWinGdi_InvertMask
+
projects / wxWidgets.git / blobdiff