+///////////////////////////////////////////////////////////////////////////////
+// Name: src/msw/dib.cpp
+// Purpose: implements wxDIB class
+// Author: Vadim Zeitlin
+// Modified by:
+// Created: 03.03.03 (replaces the old file with the same name)
+// RCS-ID: $Id$
+// Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
+// License: wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+ #include "wx/log.h"
+#endif //WX_PRECOMP
+
+#include "wx/image.h"
+
+#include "wx/msw/dib.h"
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDIB creation
+// ----------------------------------------------------------------------------
+
+bool wxDIB::Create(int width, int height, int depth)
+{
+ // we don't handle the palette yet
+ wxASSERT_MSG( depth == 24 || depth == 32,
+ _T("unsupported image depth in wxDIB::Create()") );
+
+ static const int infosize = sizeof(BITMAPINFOHEADER);
+
+ BITMAPINFO *info = (BITMAPINFO *)malloc(infosize);
+ wxCHECK_MSG( info, NULL, _T("malloc(BITMAPINFO) failed") );
+
+ memset(info, 0, infosize);
+
+ info->bmiHeader.biSize = infosize;
+ info->bmiHeader.biWidth = width;
+ info->bmiHeader.biHeight = -height;
+ info->bmiHeader.biPlanes = 1;
+ info->bmiHeader.biBitCount = depth;
+ info->bmiHeader.biCompression = BI_RGB;
+ info->bmiHeader.biSizeImage = GetLineSize(width, depth)*height;
+
+ // No need to report an error here. If it fails, we just won't use a
+ // file mapping and CreateDIBSection will just allocate memory for us.
+ m_handle = ::CreateDIBSection
+ (
+ 0, // hdc (unused with DIB_RGB_COLORS)
+ info, // bitmap description
+ DIB_RGB_COLORS, // use RGB, not palette
+ &m_data, // [out] DIB bits
+ NULL, // don't use file mapping
+ 0 // file mapping offset (not used here)
+ );
+
+ free(info);
+
+ if ( !m_handle )
+ {
+ wxLogLastError(wxT("CreateDIBSection"));
+
+ return false;
+ }
+
+ m_width = width;
+ m_height = height;
+ m_depth = depth;
+
+ return true;
+}
+
+// ----------------------------------------------------------------------------
+// wxDIB accessors
+// ----------------------------------------------------------------------------
+
+void wxDIB::DoGetObject() const
+{
+ // only do something if we have a valid DIB but we don't [yet] have valid
+ // data
+ if ( m_handle && !m_data )
+ {
+ // although all the info we need is in BITMAP and so we don't really
+ // need DIBSECTION we still ask for it as modifying the bit values only
+ // works for the real DIBs and not for the bitmaps and it's better to
+ // check for this now rather than trying to find out why it doesn't
+ // work later
+ DIBSECTION ds;
+ if ( !::GetObject(m_handle, sizeof(ds), &ds) )
+ {
+ wxLogLastError(_T("GetObject(hDIB)"));
+
+ return;
+ }
+
+ wxDIB *self = wxConstCast(this, wxDIB);
+
+ self->m_width = ds.dsBm.bmWidth;
+ self->m_height = ds.dsBm.bmHeight;
+ self->m_depth = ds.dsBm.bmBitsPixel;
+ self->m_data = ds.dsBm.bmBits;
+ }
+}
+
+// ----------------------------------------------------------------------------
+// wxImage support
+// ----------------------------------------------------------------------------
+
+#if wxUSE_IMAGE
+
+bool wxDIB::Create(const wxImage& image)
+{
+ wxCHECK_MSG( image.Ok(), false, _T("invalid wxImage in wxDIB ctor") );
+
+ const int h = image.GetHeight();
+ const int w = image.GetWidth();
+
+ // if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise
+ // a 24bpp RGB is sufficient
+ const bool hasAlpha = image.HasAlpha();
+ const int bpp = hasAlpha ? 32 : 24;
+
+ if ( !Create(w, h, bpp) )
+ return false;
+
+ // DIBs are stored in bottom to top order so we need to copy bits line by
+ // line and starting from the end
+ const int srcBytesPerLine = w * 3;
+ const int dstBytesPerLine = GetLineSize(w, bpp);
+ const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine);
+ const unsigned char *alpha = hasAlpha ? image.GetAlpha() + (h - 1)*w : NULL;
+ unsigned char *dstLineStart = (unsigned char *)m_data;
+ for ( int y = 0; y < h; y++ )
+ {
+ // copy one DIB line
+ unsigned char *dst = dstLineStart;
+ for ( int x = 0; x < w; x++ )
+ {
+ // also, the order of RGB is inversed for DIBs
+ *dst++ = src[2];
+ *dst++ = src[1];
+ *dst++ = src[0];
+
+ src += 3;
+
+ if ( alpha )
+ *dst++ = *alpha++;
+ }
+
+ // pass to the previous line in the image
+ src -= 2*srcBytesPerLine;
+ if ( alpha )
+ alpha -= 2*w;
+
+ // and to the next one in the DIB
+ dstLineStart += dstBytesPerLine;
+ }
+
+ return true;
+}
+
+#endif // wxUSE_IMAGE
+
+// ============================================================================
+// old DIB code, to be integrated in wxDIB class
+// ============================================================================
+
/*******************************************************************************
- * *
- * MODULE : DIB.CC *
- * *
+ * *
+ * MODULE : DIB.CC *
+ * *
* DESCRIPTION : Routines for dealing with Device Independent Bitmaps. *
- * *
- * FUNCTIONS : *
- * *
+ * *
+ * FUNCTIONS : *
+ * *
* wxReadDIB() - Reads a DIB *
- * *
- * WriteDIB() - Writes a global handle in CF_DIB format*
- * to a file. *
- * *
- * wxPaletteSize() - Calculates the palette size in bytes *
- * of given DIB *
- * *
- * DibNumColors() - Determines the number of colors in DIB *
- * *
- * DibFromBitmap() - Creates a DIB repr. the DDB passed in. *
- * *
- * *
- * lread() - Private routine to read more than 64k *
- * *
- * lwrite() - Private routine to write more than 64k *
- * *
+ * *
+ * WriteDIB() - Writes a global handle in CF_DIB format*
+ * to a file. *
+ * *
+ * wxPaletteSize() - Calculates the palette size in bytes *
+ * of given DIB *
+ * *
+ * DibNumColors() - Determines the number of colors in DIB *
+ * *
+ * DibFromBitmap() - Creates a DIB repr. the DDB passed in. *
+ * *
+ * *
+ * lread() - Private routine to read more than 64k *
+ * *
+ * lwrite() - Private routine to write more than 64k *
+ * *
*******************************************************************************/
// For compilers that support precompilation, includes "wx.h".
#endif
#ifndef WX_PRECOMP
-#include "wx/setup.h"
-#include "wx/defs.h"
#include "wx/bitmap.h"
+#include "wx/log.h"
+#include "wx/intl.h"
#endif
#include <windows.h>
#include "wx/msw/dib.h"
-#ifndef __TWIN32__
-#ifndef wxUSE_NORLANDER_HEADERS
-#ifdef __GNUWIN32__
-#include "wx/msw/gnuwin32/extra.h"
-#endif
-#endif
+#ifdef __GNUWIN32_OLD__
+ #include "wx/msw/gnuwin32/extra.h"
#endif
#ifndef SEEK_CUR
/* flags for _lseek */
-#define SEEK_CUR 1
-#define SEEK_END 2
-#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#define SEEK_SET 0
#endif
-#define MAXREAD 32768 /* Number of bytes to be read during */
- /* each read operation. */
+#define MAXREAD 32768 /* Number of bytes to be read during */
+ /* each read operation. */
/* Header signatutes for various resources */
-#define BFT_ICON 0x4349 /* 'IC' */
-#define BFT_BITMAP 0x4d42 /* 'BM' */
-#define BFT_CURSOR 0x5450 /* 'PT(' */
+#define BFT_ICON 0x4349 /* 'IC' */
+#define BFT_BITMAP 0x4d42 /* 'BM' */
+#define BFT_CURSOR 0x5450 /* 'PT(' */
/* macro to determine if resource is a DIB */
#define ISDIB(bft) ((bft) == BFT_BITMAP)
/* Macro to align given value to the closest DWORD (unsigned long ) */
-#define ALIGNULONG(i) ((i+3)/4*4)
+#define ALIGNULONG(i) ((i+3)/4*4)
/* Macro to determine to round off the given value to the closest byte */
-#define WIDTHBYTES(i) ((i+31)/32*4)
+#define WIDTHBYTES(i) ((i+31)/32*4)
-#define PALVERSION 0x300
-#define MAXPALETTE 256 /* max. # supported palette entries */
+#define PALVERSION 0x300
+#define MAXPALETTE 256 /* max. # supported palette entries */
static DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
-static BOOL WriteDIB (LPTSTR szFile,HANDLE hdib);
-WORD wxPaletteSize (VOID FAR * pv); // This is non-static as some apps use it externally
-static WORD DibNumColors (VOID FAR * pv);
-// HANDLE DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
+static BOOL WriteDIB (LPTSTR szFile,HANDLE hdib);
+WORD wxPaletteSize (VOID FAR * pv); // This is non-static as some apps use it externally
+static WORD DibNumColors (VOID FAR * pv);
+// HANDLE DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
static BOOL PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
/****************************************************************************
- * *
- * FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
- * *
- * PURPOSE : Write a global handle in CF_DIB format to a file. *
- * *
- * RETURNS : TRUE - if successful. *
- * FALSE - otherwise *
- * *
+ * *
+ * FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
+ * *
+ * PURPOSE : Write a global handle in CF_DIB format to a file. *
+ * *
+ * RETURNS : TRUE - if successful. *
+ * FALSE - otherwise *
+ * *
****************************************************************************/
static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
{
- BITMAPFILEHEADER hdr;
- LPBITMAPINFOHEADER lpbi;
- int fh;
- OFSTRUCT of;
+ BITMAPFILEHEADER hdr;
+ LPBITMAPINFOHEADER lpbi;
+ int fh;
+ OFSTRUCT of;
- if (!hdib)
- return FALSE;
+ if (!hdib)
+ return FALSE;
- fh = OpenFile(wxFNCONV(szFile), &of, OF_CREATE | OF_READWRITE);
- if (fh == -1)
- return FALSE;
+ fh = OpenFile(wxConvertWX2MB(szFile), &of, OF_CREATE | OF_READWRITE);
+ if (fh == -1)
+ return FALSE;
#ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));
lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
#endif
/* Fill in the fields of the file header */
- hdr.bfType = BFT_BITMAP;
- hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
- hdr.bfReserved1 = 0;
- hdr.bfReserved2 = 0;
- hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
- wxPaletteSize(lpbi);
+ hdr.bfType = BFT_BITMAP;
+ hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
+ hdr.bfReserved1 = 0;
+ hdr.bfReserved2 = 0;
+ hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
+ wxPaletteSize(lpbi);
/* Write the file header */
- _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
+ _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
/* Write the DIB header and the bits */
- lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
+ lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
- GlobalUnlock(hdib);
- _lclose(fh);
- return TRUE;
+ GlobalUnlock(hdib);
+ _lclose(fh);
+ return TRUE;
}
/****************************************************************************
- * *
- * FUNCTION : wxPaletteSize(VOID FAR * pv) *
- * *
+ * *
+ * FUNCTION : wxPaletteSize(VOID FAR * pv) *
+ * *
* PURPOSE : Calculates the palette size in bytes. If the info. block *
- * is of the BITMAPCOREHEADER type, the number of colors is *
- * multiplied by 3 to give the palette size, otherwise the *
- * number of colors is multiplied by 4. *
- * *
- * RETURNS : Palette size in number of bytes. *
- * *
+ * is of the BITMAPCOREHEADER type, the number of colors is *
+ * multiplied by 3 to give the palette size, otherwise the *
+ * number of colors is multiplied by 4. *
+ * *
+ * RETURNS : Palette size in number of bytes. *
+ * *
****************************************************************************/
WORD wxPaletteSize(VOID FAR * pv)
{
- LPBITMAPINFOHEADER lpbi;
- WORD NumColors;
+ LPBITMAPINFOHEADER lpbi;
+ WORD NumColors;
- lpbi = (LPBITMAPINFOHEADER) pv;
- NumColors = DibNumColors(lpbi);
+ lpbi = (LPBITMAPINFOHEADER) pv;
+ NumColors = DibNumColors(lpbi);
- if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
- return NumColors * sizeof(RGBTRIPLE);
- else
- return NumColors * sizeof(RGBQUAD);
+ if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
+ return (WORD)(NumColors * sizeof(RGBTRIPLE));
+ else
+ return (WORD)(NumColors * sizeof(RGBQUAD));
}
/****************************************************************************
- * *
- * FUNCTION : DibNumColors(VOID FAR * pv) *
- * *
+ * *
+ * FUNCTION : DibNumColors(VOID FAR * pv) *
+ * *
* PURPOSE : Determines the number of colors in the DIB by looking at *
- * the BitCount filed in the info block. *
- * *
- * RETURNS : The number of colors in the DIB. *
- * *
+ * the BitCount filed in the info block. *
+ * *
+ * RETURNS : The number of colors in the DIB. *
+ * *
****************************************************************************/
static WORD DibNumColors(VOID FAR *pv)
{
- int bits;
- BITMAPINFOHEADER *lpbi;
- BITMAPCOREHEADER *lpbc;
+ int bits;
+ BITMAPINFOHEADER *lpbi;
+ BITMAPCOREHEADER *lpbc;
- lpbi = ((BITMAPINFOHEADER*) pv);
- lpbc = ((BITMAPCOREHEADER*) pv);
+ lpbi = ((BITMAPINFOHEADER*) pv);
+ lpbc = ((BITMAPCOREHEADER*) pv);
- /* With the BITMAPINFO format headers, the size of the palette
- * is in biClrUsed, whereas in the BITMAPCORE - style headers, it
- * is dependent on the bits per pixel ( = 2 raised to the power of
- * bits/pixel).
+ /* With the BITMAPINFO format headers, the size of the palette
+ * is in biClrUsed, whereas in the BITMAPCORE - style headers, it
+ * is dependent on the bits per pixel ( = 2 raised to the power of
+ * bits/pixel).
*/
- if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
- if (lpbi->biClrUsed != 0)
- return (WORD) lpbi->biClrUsed;
- bits = lpbi->biBitCount;
- }
- else
- bits = lpbc->bcBitCount;
-
- switch (bits) {
+ if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
+ if (lpbi->biClrUsed != 0)
+ return (WORD) lpbi->biClrUsed;
+ bits = lpbi->biBitCount;
+ }
+ else
+ bits = lpbc->bcBitCount;
+
+ switch (bits) {
case 1:
- return 2;
+ return 2;
case 4:
- return 16;
+ return 16;
case 8:
- return 256;
+ return 256;
default:
- /* A 24 bitcount DIB has no color table */
- return 0;
- }
+ /* A 24 bitcount DIB has no color table */
+ return 0;
+ }
}
/****************************************************************************
- * *
- * FUNCTION : DibFromBitmap() *
- * *
- * PURPOSE : Will create a global memory block in DIB format that *
- * represents the Device-dependent bitmap (DDB) passed in. *
- * *
- * RETURNS : A handle to the DIB *
- * *
+ * *
+ * FUNCTION : DibFromBitmap() *
+ * *
+ * PURPOSE : Will create a global memory block in DIB format that *
+ * represents the Device-dependent bitmap (DDB) passed in. *
+ * *
+ * RETURNS : A handle to the DIB *
+ * *
****************************************************************************/
#if NOTHING
static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
{
- BITMAP bm;
- BITMAPINFOHEADER bi;
- BITMAPINFOHEADER FAR *lpbi;
- DWORD dwLen;
- HANDLE hdib;
- HANDLE h;
- HDC hdc;
-
- if (!hbm)
- return NULL;
-
- if (hpal == NULL)
- hpal = GetStockObject(DEFAULT_PALETTE);
-
- GetObject(hbm, sizeof (bm), (LPSTR) &bm);
-
- if (biBits == 0)
- biBits = bm.bmPlanes * bm.bmBitsPixel;
-
- bi.biSize = sizeof(BITMAPINFOHEADER);
- bi.biWidth = bm.bmWidth;
- bi.biHeight = bm.bmHeight;
- bi.biPlanes = 1;
- bi.biBitCount = biBits;
- bi.biCompression = biStyle;
- bi.biSizeImage = 0;
- bi.biXPelsPerMeter = 0;
- bi.biYPelsPerMeter = 0;
- bi.biClrUsed = 0;
- bi.biClrImportant = 0;
-
- dwLen = bi.biSize + wxPaletteSize(&bi);
-
- hdc = GetDC((HWND) NULL);
- hpal = SelectPalette(hdc, hpal, FALSE);
- RealizePalette(hdc);
-
- hdib = GlobalAlloc(GHND, dwLen);
-
- if (!hdib) {
- SelectPalette(hdc, hpal, FALSE);
- ReleaseDC(NULL, hdc);
- return NULL;
- }
+ BITMAP bm;
+ BITMAPINFOHEADER bi;
+ BITMAPINFOHEADER FAR *lpbi;
+ DWORD dwLen;
+ HANDLE hdib;
+ HANDLE h;
+ HDC hdc;
+
+ if (!hbm)
+ return NULL;
+
+ if (hpal == NULL)
+ hpal = GetStockObject(DEFAULT_PALETTE);
+
+ GetObject(hbm, sizeof (bm), (LPSTR) &bm);
+
+ if (biBits == 0)
+ biBits = bm.bmPlanes * bm.bmBitsPixel;
+
+ bi.biSize = sizeof(BITMAPINFOHEADER);
+ bi.biWidth = bm.bmWidth;
+ bi.biHeight = bm.bmHeight;
+ bi.biPlanes = 1;
+ bi.biBitCount = biBits;
+ bi.biCompression = biStyle;
+ bi.biSizeImage = 0;
+ bi.biXPelsPerMeter = 0;
+ bi.biYPelsPerMeter = 0;
+ bi.biClrUsed = 0;
+ bi.biClrImportant = 0;
+
+ dwLen = bi.biSize + wxPaletteSize(&bi);
+
+ hdc = GetDC((HWND) NULL);
+ hpal = SelectPalette(hdc, hpal, FALSE);
+ RealizePalette(hdc);
+
+ hdib = GlobalAlloc(GHND, dwLen);
+
+ if (!hdib) {
+ SelectPalette(hdc, hpal, FALSE);
+ ReleaseDC(NULL, hdc);
+ return NULL;
+ }
#ifdef __WINDOWS_386__
- lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
+ lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
#else
- lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
+ lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
#endif
- *lpbi = bi;
+ *lpbi = bi;
- /* call GetDIBits with a NULL lpBits param, so it will calculate the
+ /* call GetDIBits with a NULL lpBits param, so it will calculate the
* biSizeImage field for us
*/
- GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
- NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
+ NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
- bi = *lpbi;
- GlobalUnlock(hdib);
+ bi = *lpbi;
+ GlobalUnlock(hdib);
/* If the driver did not fill in the biSizeImage field, make one up */
- if (bi.biSizeImage == 0) {
- bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
-
- if (biStyle != BI_RGB)
- bi.biSizeImage = (bi.biSizeImage * 3) / 2;
- }
-
- /* realloc the buffer big enough to hold all the bits */
- dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage;
- if (h = GlobalReAlloc(hdib, dwLen, 0))
- hdib = h;
- else {
- GlobalFree(hdib);
- hdib = NULL;
-
- SelectPalette(hdc, hpal, FALSE);
- ReleaseDC(NULL, hdc);
- return hdib;
- }
-
- /* call GetDIBits with a NON-NULL lpBits param, and actualy get the
+ if (bi.biSizeImage == 0) {
+ bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
+
+ if (biStyle != BI_RGB)
+ bi.biSizeImage = (bi.biSizeImage * 3) / 2;
+ }
+
+ /* realloc the buffer big enough to hold all the bits */
+ dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage;
+ if (h = GlobalReAlloc(hdib, dwLen, 0))
+ hdib = h;
+ else {
+ GlobalFree(hdib);
+ hdib = NULL;
+
+ SelectPalette(hdc, hpal, FALSE);
+ ReleaseDC(NULL, hdc);
+ return hdib;
+ }
+
+ /* call GetDIBits with a NON-NULL lpBits param, and actualy get the
* bits this time
*/
#ifdef __WINDOWS_386__
- lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
+ lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
#else
- lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
+ lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
#endif
- if (GetDIBits(hdc,
- hbm,
- 0,
- (WORD) bi.biHeight,
- (LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi),
- (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
- GlobalUnlock(hdib);
- hdib = NULL;
- SelectPalette(hdc, hpal, FALSE);
- ReleaseDC((HWND) NULL, hdc);
- return NULL;
- }
-
- bi = *lpbi;
- GlobalUnlock(hdib);
-
- SelectPalette(hdc, hpal, FALSE);
- ReleaseDC(NULL, hdc);
- return hdib;
+ if (GetDIBits(hdc,
+ hbm,
+ 0,
+ (WORD) bi.biHeight,
+ (LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi),
+ (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
+ GlobalUnlock(hdib);
+ hdib = NULL;
+ SelectPalette(hdc, hpal, FALSE);
+ ReleaseDC((HWND) NULL, hdc);
+ return NULL;
+ }
+
+ bi = *lpbi;
+ GlobalUnlock(hdib);
+
+ SelectPalette(hdc, hpal, FALSE);
+ ReleaseDC(NULL, hdc);
+ return hdib;
}
#endif
/************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
/****************************************************************************
- * *
- * FUNCTION : lread(int fh, VOID FAR *pv, DWORD ul) *
- * *
+ * *
+ * FUNCTION : lread(int fh, VOID FAR *pv, DWORD ul) *
+ * *
* PURPOSE : Reads data in steps of 32k till all the data has been read.*
- * *
- * RETURNS : 0 - If read did not proceed correctly. *
- * number of bytes read otherwise. *
- * *
+ * *
+ * RETURNS : 0 - If read did not proceed correctly. *
+ * number of bytes read otherwise. *
+ * *
****************************************************************************/
static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
{
- DWORD ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
- BYTE *hp = (BYTE *) pv;
+ DWORD ulT = ul;
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+ BYTE *hp = (BYTE *) pv;
#else
- BYTE huge *hp = (BYTE huge *) pv;
+ BYTE huge *hp = (BYTE huge *) pv;
#endif
- while (ul > (DWORD) MAXREAD) {
- if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
- return 0;
- ul -= MAXREAD;
- hp += MAXREAD;
- }
- if (_lread(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
- return 0;
- return ulT;
+ while (ul > (DWORD) MAXREAD) {
+ if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
+ return 0;
+ ul -= MAXREAD;
+ hp += MAXREAD;
+ }
+ if (_lread(fh, (LPSTR) hp, (WXUINT) ul) != (WXUINT) ul)
+ return 0;
+ return ulT;
}
/****************************************************************************
- * *
- * FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) *
- * *
+ * *
+ * FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) *
+ * *
* PURPOSE : Writes data in steps of 32k till all the data is written. *
- * *
- * RETURNS : 0 - If write did not proceed correctly. *
- * number of bytes written otherwise. *
- * *
+ * *
+ * RETURNS : 0 - If write did not proceed correctly. *
+ * number of bytes written otherwise. *
+ * *
****************************************************************************/
static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
{
- DWORD ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
- BYTE *hp = (BYTE *) pv;
+ DWORD ulT = ul;
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+ BYTE *hp = (BYTE *) pv;
#else
- BYTE huge *hp = (BYTE huge *) pv;
+ BYTE huge *hp = (BYTE huge *) pv;
#endif
- while (ul > MAXREAD) {
- if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
- return 0;
- ul -= MAXREAD;
- hp += MAXREAD;
- }
- if (_lwrite(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
- return 0;
- return ulT;
+ while (ul > MAXREAD) {
+ if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
+ return 0;
+ ul -= MAXREAD;
+ hp += MAXREAD;
+ }
+ if (_lwrite(fh, (LPSTR) hp, (WXUINT) ul) != (WXUINT) ul)
+ return 0;
+ return ulT;
}
/****************************************************************************
* FUNCTION : ReadDIB(hWnd)
*
* PURPOSE : Reads a DIB from a file, obtains a handle to its
- * BITMAPINFO struct. and loads the DIB. Once the DIB
+ * BITMAPINFO struct. and loads the DIB. Once the DIB
* is loaded, the function also creates a bitmap and
* palette out of the DIB for a device-dependent form.
*
* RETURNS : TRUE - DIB loaded and bitmap/palette created
* The DIBINIT structure pointed to by pInfo is
* filled with the appropriate handles.
- * FALSE - otherwise
+ * FALSE - otherwise
*
****************************************************************************/
BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
{
int fh;
LPBITMAPINFOHEADER lpbi;
- OFSTRUCT of;
+ OFSTRUCT of;
BITMAPFILEHEADER bf;
- WORD nNumColors;
+ WORD nNumColors;
BOOL result = FALSE;
- wxChar str[128];
WORD offBits;
HDC hDC;
BOOL bCoreHead = FALSE;
/* Open the file and get a handle to it's BITMAPINFO */
- fh = OpenFile (wxFNCONV(lpFileName), &of, OF_READ);
+ fh = OpenFile (wxConvertWX2MB(lpFileName), &of, OF_READ);
if (fh == -1) {
- wsprintf(str,wxT("Can't open file '%s'"), lpFileName);
- MessageBox(NULL, str, wxT("Error"), MB_ICONSTOP | MB_OK);
- return (0);
+ wxLogError(_("Can't open file '%s'"), lpFileName);
+ return (0);
}
hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
- 256 * sizeof(RGBQUAD)));
+ 256 * sizeof(RGBQUAD)));
if (!hDIB)
- return(0);
+ return(0);
#ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
/* read the BITMAPFILEHEADER */
if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
- goto ErrExit;
+ goto ErrExit;
- if (bf.bfType != 0x4d42) /* 'BM' */
- goto ErrExit;
+ if (bf.bfType != 0x4d42) /* 'BM' */
+ goto ErrExit;
if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
- goto ErrExit;
+ goto ErrExit;
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
{
- lpbi->biSize = sizeof(BITMAPINFOHEADER);
- lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
- lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
- lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
- lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
- bCoreHead = TRUE;
+ lpbi->biSize = sizeof(BITMAPINFOHEADER);
+ lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
+ lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
+ lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
+ lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
+ bCoreHead = TRUE;
}
else
{
- // get to the start of the header and read INFOHEADER
+ // get to the start of the header and read INFOHEADER
_llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);
- if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
- goto ErrExit;
+ if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
+ goto ErrExit;
}
nNumColors = (WORD)lpbi->biClrUsed;
if ( nNumColors == 0 )
{
- /* no color table for 24-bit, default size otherwise */
- if (lpbi->biBitCount != 24)
- nNumColors = 1 << lpbi->biBitCount; /* standard size table */
+ /* no color table for 24-bit, default size otherwise */
+ if (lpbi->biBitCount != 24)
+ nNumColors = 1 << lpbi->biBitCount; /* standard size table */
}
- /* fill in some default values if they are zero */
+ /* fill in some default values if they are zero */
if (lpbi->biClrUsed == 0)
- lpbi->biClrUsed = nNumColors;
+ lpbi->biClrUsed = nNumColors;
if (lpbi->biSizeImage == 0)
{
- lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
- * lpbi->biHeight;
+ lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
+ * lpbi->biHeight;
}
/* get a proper-sized buffer for header, color table and bits */
GlobalUnlock(hDIB);
hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
- nNumColors * sizeof(RGBQUAD) +
- lpbi->biSizeImage, 0);
- if (!hDIB) /* can't resize buffer for loading */
- goto ErrExit2;
+ nNumColors * sizeof(RGBQUAD) +
+ lpbi->biSizeImage, 0);
+ if (!hDIB) /* can't resize buffer for loading */
+ goto ErrExit2;
#ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
/* read the color table */
if (!bCoreHead)
- _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
+ _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
else
{
- signed int i;
- RGBQUAD FAR *pQuad;
- RGBTRIPLE FAR *pTriple;
-
- _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
-
- pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
- pTriple = (RGBTRIPLE FAR *) pQuad;
- for (i = nNumColors - 1; i >= 0; i--)
- {
- pQuad[i].rgbRed = pTriple[i].rgbtRed;
- pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
- pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
- pQuad[i].rgbReserved = 0;
- }
+ signed int i;
+ RGBQUAD FAR *pQuad;
+ RGBTRIPLE FAR *pTriple;
+
+ _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
+
+ pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
+ pTriple = (RGBTRIPLE FAR *) pQuad;
+ for (i = nNumColors - 1; i >= 0; i--)
+ {
+ pQuad[i].rgbRed = pTriple[i].rgbtRed;
+ pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
+ pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
+ pQuad[i].rgbReserved = 0;
+ }
}
/* offset to the bits from start of DIB header */
- offBits = (WORD)lpbi->biSize + nNumColors * sizeof(RGBQUAD);
+ offBits = (WORD)(lpbi->biSize + nNumColors * sizeof(RGBQUAD));
if (bf.bfOffBits != 0L)
{
if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
{
- GlobalUnlock(hDIB);
-
- hDC = GetDC(NULL);
- if (!MakeBitmapAndPalette(hDC, hDIB, palette,
- bitmap))
- {
- ReleaseDC(NULL,hDC);
- goto ErrExit2;
- }
- else
- {
- ReleaseDC(NULL,hDC);
+ GlobalUnlock(hDIB);
+
+ hDC = GetDC(NULL);
+ if (!MakeBitmapAndPalette(hDC, hDIB, palette,
+ bitmap))
+ {
+ ReleaseDC(NULL,hDC);
+ goto ErrExit2;
+ }
+ else
+ {
+ ReleaseDC(NULL,hDC);
GlobalFree(hDIB);
- result = TRUE;
- }
+ result = TRUE;
+ }
}
else
{
ErrExit:
- GlobalUnlock(hDIB);
+ GlobalUnlock(hDIB);
ErrExit2:
- GlobalFree(hDIB);
+ GlobalFree(hDIB);
}
_lclose(fh);
*
****************************************************************************/
static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
- HPALETTE * phPal, HBITMAP * phBitmap)
+ HPALETTE * phPal, HBITMAP * phBitmap)
{
LPBITMAPINFOHEADER lpInfo;
BOOL result = FALSE;
hPalette = wxMakeDIBPalette(lpInfo);
if ( hPalette )
{
- // Need to realize palette for converting DIB to bitmap.
- hOldPal = SelectPalette(hDC, hPalette, TRUE);
- RealizePalette(hDC);
-
- lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
- (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
- hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
- (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
-
- SelectPalette(hDC, hOldPal, TRUE);
- RealizePalette(hDC);
-
- if (!hBitmap)
- DeleteObject(hPalette);
- else
- {
- *phBitmap = hBitmap;
- *phPal = hPalette;
- result = TRUE;
- }
+ // Need to realize palette for converting DIB to bitmap.
+ hOldPal = SelectPalette(hDC, hPalette, TRUE);
+ RealizePalette(hDC);
+
+ lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
+ (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
+ hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
+ (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
+
+ SelectPalette(hDC, hOldPal, TRUE);
+ RealizePalette(hDC);
+
+ if (!hBitmap)
+ DeleteObject(hPalette);
+ else
+ {
+ *phBitmap = hBitmap;
+ *phPal = hPalette;
+ result = TRUE;
+ }
}
+
+ GlobalUnlock (hDIB); // glt
+
return(result);
}
/****************************************************************************
- * *
- * FUNCTION : wxMakeDIBPalette(lpInfo) *
- * *
+ * *
+ * FUNCTION : wxMakeDIBPalette(lpInfo) *
+ * *
* PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
- * the color table.
+ * the color table.
*
- * *
+ * *
* RETURNS : non-zero - handle of a corresponding palette
- * zero - unable to create palette
- * *
+ * zero - unable to create palette
+ * *
****************************************************************************/
HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
{
-#ifdef __WXWINE__
- return (FALSE);
-#else
LPLOGPALETTE npPal;
RGBQUAD far *lpRGB;
HPALETTE hLogPal;
if (lpInfo->biClrUsed)
{
/*
- npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
- (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
+ npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
+ (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
*/
- npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
- (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
+ npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
+ (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
if (!npPal)
- return(FALSE);
+ return NULL;
- npPal->palVersion = 0x300;
- npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
+ npPal->palVersion = 0x300;
+ npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
- /* get pointer to the color table */
- lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);
+ /* get pointer to the color table */
+ lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);
- /* copy colors from the color table to the LogPalette structure */
- for (i = 0; i < lpInfo->biClrUsed; i++, lpRGB++)
- {
- npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
- npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
- npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
- npPal->palPalEntry[i].peFlags = 0;
- }
+ /* copy colors from the color table to the LogPalette structure */
+ for (i = 0; (DWORD)i < lpInfo->biClrUsed; i++, lpRGB++)
+ {
+ npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
+ npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
+ npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
+ npPal->palPalEntry[i].peFlags = 0;
+ }
- hLogPal = CreatePalette((LPLOGPALETTE)npPal);
-// LocalFree((HANDLE)npPal);
+ hLogPal = CreatePalette((LPLOGPALETTE)npPal);
+// LocalFree((HANDLE)npPal);
free(npPal);
- return(hLogPal);
+ return(hLogPal);
}
/* 24-bit DIB with no color table. return default palette. Another
** some good color choices.
*/
else
- return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
-#endif
-
+ return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
}
bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
{
- HBITMAP hBitmap;
- HPALETTE hPalette;
+ HBITMAP hBitmap = NULL;
+ HPALETTE hPalette = NULL;
bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);
if (!success)
{
- DeleteObject(hPalette);
+ if (hPalette)
+ DeleteObject(hPalette);
return FALSE;
}
if (hPalette)
{
+#if wxUSE_PALETTE
if (pal)
{
*pal = new wxPalette;
(*pal)->SetHPALETTE((WXHPALETTE) hPalette);
}
else
+#endif // wxUSE_PALETTE
DeleteObject(hPalette);
}
else if (pal)
bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)
{
HPALETTE hPalette = 0;
+#if wxUSE_PALETTE
if (colourmap)
hPalette = (HPALETTE) colourmap->GetHPALETTE();
+#endif // wxUSE_PALETTE
HANDLE dibHandle = wxBitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
if (dibHandle)
else return FALSE;
}
-
projects / wxWidgets.git / blobdiff