#include "wx/log.h"
#endif //WX_PRECOMP
-#include "wx/image.h"
+#include "wx/bitmap.h"
+#include "wx/intl.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if !defined(__MWERKS__) && !defined(__SALFORDC__)
+#include <memory.h>
+#endif
+
+#ifdef __GNUWIN32_OLD__
+ #include "wx/msw/gnuwin32/extra.h"
+#endif
+#include "wx/image.h"
#include "wx/msw/dib.h"
// ============================================================================
info->bmiHeader.biSize = infosize;
info->bmiHeader.biWidth = width;
- info->bmiHeader.biHeight = -height;
+
+ // we use positive height here which corresponds to a DIB with normal, i.e.
+ // bottom to top, order -- normally using negative height (which means
+ // reversed for MS and hence natural for all the normal people top to
+ // bottom line scan order) could be used to avoid the need for the image
+ // reversal in Create(image) but this doesn't work under NT, only Win9x!
+ info->bmiHeader.biHeight = height;
+
info->bmiHeader.biPlanes = 1;
info->bmiHeader.biBitCount = depth;
info->bmiHeader.biCompression = BI_RGB;
return true;
}
+// ----------------------------------------------------------------------------
+// Loading/saving the DIBs
+// ----------------------------------------------------------------------------
+
+bool wxDIB::Load(const wxString& filename)
+{
+ m_handle = (HBITMAP)::LoadImage
+ (
+ wxGetInstance(),
+ filename,
+ IMAGE_BITMAP,
+ 0, 0, // don't specify the size
+ LR_CREATEDIBSECTION | LR_LOADFROMFILE
+ );
+ if ( !m_handle )
+ {
+ wxLogLastError(_T("LoadImage(LR_CREATEDIBSECTION | LR_LOADFROMFILE)"));
+
+ return false;
+ }
+
+ return true;
+}
+
// ----------------------------------------------------------------------------
// wxDIB accessors
// ----------------------------------------------------------------------------
if ( !::GetObject(m_handle, sizeof(ds), &ds) )
{
wxLogLastError(_T("GetObject(hDIB)"));
-
return;
}
}
}
+HBITMAP wxDIB::CreateDDB(HDC hdc) const
+{
+ wxCHECK_MSG( m_handle, 0, _T("wxDIB::CreateDDB(): invalid object") );
+
+ DIBSECTION ds;
+ if ( !::GetObject(m_handle, sizeof(ds), &ds) )
+ {
+ wxLogLastError(_T("GetObject(hDIB)"));
+
+ return 0;
+ }
+
+ HBITMAP hbitmap = ::CreateCompatibleBitmap
+ (
+ hdc ? hdc : ScreenHDC(),
+ ds.dsBm.bmWidth,
+ ds.dsBm.bmHeight
+ );
+ if ( !hbitmap )
+ {
+ wxLogLastError(_T("CreateCompatibleBitmap()"));
+
+ return 0;
+ }
+
+ MemoryHDC hdcMem;
+ SelectInHDC select(hdcMem, hbitmap);
+ if ( !select )
+ {
+ wxLogLastError(_T("SelectObjct(hBitmap)"));
+ }
+
+ if ( !::SetDIBits
+ (
+ hdcMem,
+ hbitmap,
+ 0,
+ ds.dsBm.bmHeight,
+ ds.dsBm.bmBits,
+ (BITMAPINFO *)&ds.dsBmih,
+ DIB_RGB_COLORS
+ ) )
+ {
+ wxLogLastError(_T("SetDIBits"));
+
+ return 0;
+ }
+
+ return hbitmap;
+}
+
+#if wxUSE_PALETTE
+
+wxPalette *wxDIB::CreatePalette() const
+{
+ wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") );
+
+ DIBSECTION ds;
+ if ( !::GetObject(m_handle, sizeof(ds), &ds) )
+ {
+ wxLogLastError(_T("GetObject(hDIB)"));
+
+ return 0;
+ }
+
+ // how many colours are we going to have in the palette?
+ DWORD biClrUsed = ds.dsBmih.biClrUsed;
+ if ( !biClrUsed )
+ {
+ // biClrUsed field might not be set
+ biClrUsed = 1 << ds.dsBmih.biBitCount;
+ }
+
+ if ( biClrUsed > 256 )
+ {
+ // only 8bpp bitmaps (and less) have palettes, so we surely don't
+ //
+ // NB: another possibility would be to return
+ // GetStockObject(DEFAULT_PALETTE) or even CreateHalftonePalette()?
+ return NULL;
+ }
+
+ // LOGPALETTE struct has only 1 element in palPalEntry array, we're
+ // going to have biClrUsed of them so add necessary space
+ LOGPALETTE *pPalette = (LOGPALETTE *)
+ malloc(sizeof(LOGPALETTE) + (biClrUsed - 1)*sizeof(PALETTEENTRY));
+ wxCHECK_MSG( pPalette, NULL, _T("out of memory") );
+
+ // initialize the palette header
+ pPalette->palVersion = 0x300; // magic number, not in docs but works
+ pPalette->palNumEntries = biClrUsed;
+
+ // and the colour table (it starts right after the end of the header)
+ const RGBQUAD *pRGB = (RGBQUAD *)((char *)&ds.dsBmih + ds.dsBmih.biSize);
+ for ( DWORD i = 0; i < biClrUsed; i++, pRGB++ )
+ {
+ pPalette->palPalEntry[i].peRed = pRGB->rgbRed;
+ pPalette->palPalEntry[i].peGreen = pRGB->rgbGreen;
+ pPalette->palPalEntry[i].peBlue = pRGB->rgbBlue;
+ pPalette->palPalEntry[i].peFlags = 0;
+ }
+
+ HPALETTE hPalette = ::CreatePalette(pPalette);
+
+ free(pPalette);
+
+ if ( !hPalette )
+ {
+ wxLogLastError(_T("CreatePalette"));
+
+ return NULL;
+ }
+
+ wxPalette *palette = new wxPalette;
+ palette->SetHPALETTE((WXHPALETTE)hPalette);
+
+ return palette;
+}
+
+#endif // wxUSE_PALETTE
+
// ----------------------------------------------------------------------------
// wxImage support
// ----------------------------------------------------------------------------
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
+ // DIBs are stored in bottom to top order (see also the comment above in
+ // Create()) 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);
// old DIB code, to be integrated in wxDIB class
// ============================================================================
-/*******************************************************************************
- * *
- * MODULE : DIB.CC *
- * *
- * DESCRIPTION : Routines for dealing with Device Independent Bitmaps. *
- * *
- * 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 *
- * *
- *******************************************************************************/
-
-// For compilers that support precompilation, includes "wx.h".
-#include "wx/wxprec.h"
-
-#if defined(__BORLANDC__)
-#pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
-#include "wx/bitmap.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#endif
-
-#include <windows.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#if !defined(__MWERKS__) && !defined(__SALFORDC__)
-#include <memory.h>
-#endif
-
-#include "wx/msw/dib.h"
-
-#ifdef __GNUWIN32_OLD__
- #include "wx/msw/gnuwin32/extra.h"
-#endif
+/*
+ * Routines for dealing with Device Independent Bitmaps.
+ *
+ * wxReadDIB() - Reads a DIB
+ * wxWriteDIB() - Writes a global handle in CF_DIB format
+ * to a file.
+ * wxPaletteSize() - Calculates the palette size in bytes
+ * of given DIB
+ * wxDibNumColors() - Determines the number of colors in DIB
+ * wxDibFromBitmap() - Creates a DIB repr. the DDB passed in.
+ * lread() - Private routine to read more than 64k
+ * lwrite() - Private routine to write more than 64k
+ */
#ifndef SEEK_CUR
/* flags for _lseek */
#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 DWORD lread(int fh, VOID FAR *pv, DWORD ul);
+static DWORD lwrite(int fh, VOID FAR *pv, DWORD ul);
-static BOOL WriteDIB (LPTSTR szFile,HANDLE hdib);
+static bool wxWriteDIB (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 *
- * *
- ****************************************************************************/
-
-static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
+static WORD wxDibNumColors (VOID FAR * pv);
+static bool wxMakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
+
+/*
+ * FUNCTION : wxWriteDIB(LPSTR szFile,HANDLE hdib)
+ * PURPOSE : Write a global handle in CF_DIB format to a file.
+ * RETURNS : TRUE - if successful.
+ * FALSE - otherwise
+ */
+
+static bool wxWriteDIB(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(wxConvertWX2MB(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;
+
+ lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
-#ifdef __WINDOWS_386__
- lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));
-#else
- 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) *
- * *
- * 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. *
- * *
- ****************************************************************************/
+/*
+ * 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.
+ */
WORD wxPaletteSize(VOID FAR * pv)
{
- LPBITMAPINFOHEADER lpbi;
- WORD NumColors;
+ LPBITMAPINFOHEADER lpbi;
+ WORD NumColors;
- lpbi = (LPBITMAPINFOHEADER) pv;
- NumColors = DibNumColors(lpbi);
+ lpbi = (LPBITMAPINFOHEADER) pv;
+ NumColors = wxDibNumColors(lpbi);
- if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
- return (WORD)(NumColors * sizeof(RGBTRIPLE));
- else
- return (WORD)(NumColors * sizeof(RGBQUAD));
+ if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
+ return (WORD)(NumColors * sizeof(RGBTRIPLE));
+ else
+ return (WORD)(NumColors * sizeof(RGBQUAD));
}
-/****************************************************************************
- * *
- * FUNCTION : DibNumColors(VOID FAR * pv) *
- * *
- * PURPOSE : Determines the number of colors in the DIB by looking at *
- * the BitCount filed in the info block. *
- * *
+/*
+ * FUNCTION : wxDibNumColors(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. *
- * *
- ****************************************************************************/
+ */
-static WORD DibNumColors(VOID FAR *pv)
+static WORD wxDibNumColors(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).
*/
- 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;
- case 4:
- return 16;
- case 8:
- return 256;
- default:
- /* A 24 bitcount DIB has no color table */
- return 0;
- }
+ 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;
+ case 4:
+ return 16;
+ case 8:
+ return 256;
+ default:
+ /* 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 *
- * *
- ****************************************************************************/
-
-#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;
- }
-
-#ifdef __WINDOWS_386__
- lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
-#else
- lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
-#endif
-
- *lpbi = bi;
-
- /* 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);
-
- 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
- * bits this time
- */
-#ifdef __WINDOWS_386__
- lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
-#else
- 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;
-}
-#endif
+/*
+ * 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.
+ */
- /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
-/****************************************************************************
- * *
- * 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. *
- * *
- ****************************************************************************/
-
-static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
+static DWORD lread(int fh, void far *pv, DWORD ul)
{
- DWORD ulT = ul;
+ DWORD ulT = ul;
#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
- BYTE *hp = (BYTE *) pv;
+ 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, (WXUINT) ul) != (WXUINT) 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) *
- * *
- * 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. *
- * *
- ****************************************************************************/
-
-static DWORD PASCAL 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.
+ */
+
+static DWORD lwrite(int fh, VOID FAR *pv, DWORD ul)
{
- DWORD ulT = ul;
+ DWORD ulT = ul;
#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
- BYTE *hp = (BYTE *) pv;
+ 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, (WXUINT) ul) != (WXUINT) 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)
- *
+/*
+ * FUNCTION : wxReadDIB(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
- *
- ****************************************************************************/
-BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
+ * FALSE - otherwise
+ */
+
+bool wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
{
int fh;
LPBITMAPINFOHEADER lpbi;
OFSTRUCT of;
BITMAPFILEHEADER bf;
WORD nNumColors;
- BOOL result = FALSE;
+ bool result = FALSE;
WORD offBits;
HDC hDC;
- BOOL bCoreHead = FALSE;
+ bool bCoreHead = FALSE;
HANDLE hDIB = 0;
/* Open the file and get a handle to it's BITMAPINFO */
}
hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
- 256 * sizeof(RGBQUAD)));
+ 256 * sizeof(RGBQUAD)));
if (!hDIB)
return(0);
-#ifdef __WINDOWS_386__
- lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
-#else
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
-#endif
/* read the BITMAPFILEHEADER */
if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
}
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;
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;
if (lpbi->biSizeImage == 0)
{
lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
- * lpbi->biHeight;
+ * 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);
+ 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));
-#else
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
-#endif
/* read the color table */
if (!bCoreHead)
GlobalUnlock(hDIB);
hDC = GetDC(NULL);
- if (!MakeBitmapAndPalette(hDC, hDIB, palette,
- bitmap))
+ if (!wxMakeBitmapAndPalette(hDC, hDIB, palette,
+ bitmap))
{
ReleaseDC(NULL,hDC);
goto ErrExit2;
else
{
ErrExit:
- GlobalUnlock(hDIB);
+ GlobalUnlock(hDIB);
ErrExit2:
- GlobalFree(hDIB);
+ GlobalFree(hDIB);
}
_lclose(fh);
return(result);
}
-/****************************************************************************
- *
- * FUNCTION : MakeBitmapAndPalette
- *
+/*
+ * FUNCTION : wxMakeBitmapAndPalette
* PURPOSE : Given a DIB, creates a bitmap and corresponding palette
* to be used for a device-dependent representation of
* of the image.
- *
* RETURNS : TRUE --> success. phPal and phBitmap are filled with
* appropriate handles. Caller is responsible
* for freeing objects.
* FALSE --> unable to create objects. both pointer are
* not valid
- *
- ****************************************************************************/
-static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
+ */
+
+static bool wxMakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
HPALETTE * phPal, HBITMAP * phBitmap)
{
LPBITMAPINFOHEADER lpInfo;
- BOOL result = FALSE;
+ bool result = FALSE;
HBITMAP hBitmap;
HPALETTE hPalette, hOldPal;
LPSTR lpBits;
-#ifdef __WINDOWS_386__
- lpInfo = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hDIB));
-#else
lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
-#endif
hPalette = wxMakeDIBPalette(lpInfo);
if ( hPalette )
RealizePalette(hDC);
lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
- (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
+ (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
- (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
+ (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
SelectPalette(hDC, hOldPal, TRUE);
RealizePalette(hDC);
}
}
- GlobalUnlock (hDIB); // glt
+ 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)
{
LPLOGPALETTE npPal;
WORD i;
/* since biClrUsed field was filled during the loading of the DIB,
- ** we know it contains the number of colors in the color table.
- */
+ * we know it contains the number of colors in the color table.
+ */
if (lpInfo->biClrUsed)
{
-/*
- npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
- (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
-*/
npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
- (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
+ (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
if (!npPal)
return NULL;
}
hLogPal = CreatePalette((LPLOGPALETTE)npPal);
-// LocalFree((HANDLE)npPal);
free(npPal);
return(hLogPal);
}
- /* 24-bit DIB with no color table. return default palette. Another
- ** option would be to create a 256 color "rainbow" palette to provide
- ** some good color choices.
- */
+ /* 24-bit DIB with no color table. Return default palette. Another
+ * option would be to create a 256 color "rainbow" palette to provide
+ * some good color choices.
+ */
else
return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
}
-bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
-{
- HBITMAP hBitmap = NULL;
- HPALETTE hPalette = NULL;
-
- bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);
-
- if (!success)
- {
- 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)
- *pal = NULL;
-
- if (hBitmap)
- {
- BITMAP bm;
- GetObject(hBitmap, sizeof(bm), (LPSTR)&bm);
-
- bitmap->SetHBITMAP((WXHBITMAP) hBitmap);
- bitmap->SetWidth(bm.bmWidth);
- bitmap->SetHeight(bm.bmHeight);
- bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);
-#if WXWIN_COMPATIBILITY_2
- bitmap->SetOk(TRUE);
-#endif // WXWIN_COMPATIBILITY_2
- return TRUE;
- }
- else return FALSE;
-}
-
-wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **pal)
-{
- wxBitmap *bitmap = new wxBitmap;
- if (wxLoadIntoBitmap(filename, bitmap, pal))
- return bitmap;
- else
- {
- delete bitmap;
- return NULL;
- }
-}
-
-//---------------------------------------------------------------------
-//
-// Function: InitBitmapInfoHeader
-//
-// Purpose: Does a "standard" initialization of a BITMAPINFOHEADER,
-// given the Width, Height, and Bits per Pixel for the
-// DIB.
-//
-// By standard, I mean that all the relevant fields are set
-// to the specified values. biSizeImage is computed, the
-// biCompression field is set to "no compression," and all
-// other fields are 0.
-//
-// Note that DIBs only allow BitsPixel values of 1, 4, 8, or
-// 24. This routine makes sure that one of these values is
-// used (whichever is most appropriate for the specified
-// nBPP).
-//
-// Parms: lpBmInfoHdr == Far pointer to a BITMAPINFOHEADER structure
-// to be filled in.
-// dwWidth == Width of DIB (not in Win 3.0 & 3.1, high
-// word MUST be 0).
-// dwHeight == Height of DIB (not in Win 3.0 & 3.1, high
-// word MUST be 0).
-// nBPP == Bits per Pixel for the DIB.
-//
-// History: Date Reason
-// 11/07/91 Created
-//
-//---------------------------------------------------------------------
+/*
+ *
+ * Function: InitBitmapInfoHeader
+ *
+ * Purpose: Does a "standard" initialization of a BITMAPINFOHEADER,
+ * given the Width, Height, and Bits per Pixel for the
+ * DIB.
+ *
+ * By standard, I mean that all the relevant fields are set
+ * to the specified values. biSizeImage is computed, the
+ * biCompression field is set to "no compression," and all
+ * other fields are 0.
+ *
+ * Note that DIBs only allow BitsPixel values of 1, 4, 8, or
+ * 24. This routine makes sure that one of these values is
+ * used (whichever is most appropriate for the specified
+ * nBPP).
+ *
+ * Parms: lpBmInfoHdr == Far pointer to a BITMAPINFOHEADER structure
+ * to be filled in.
+ * dwWidth == Width of DIB (not in Win 3.0 & 3.1, high
+ * word MUST be 0).
+ * dwHeight == Height of DIB (not in Win 3.0 & 3.1, high
+ * word MUST be 0).
+ * nBPP == Bits per Pixel for the DIB.
+ *
+ */
static void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
DWORD dwWidth,
DWORD dwHeight,
int nBPP)
{
-// _fmemset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
- memset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
-
- lpBmInfoHdr->biSize = sizeof (BITMAPINFOHEADER);
- lpBmInfoHdr->biWidth = dwWidth;
- lpBmInfoHdr->biHeight = dwHeight;
- lpBmInfoHdr->biPlanes = 1;
-
- if (nBPP <= 1)
- nBPP = 1;
- else if (nBPP <= 4)
- nBPP = 4;
- else if (nBPP <= 8)
- nBPP = 8;
-/* Doesn't work
- else if (nBPP <= 16)
- nBPP = 16;
-*/
- else
- nBPP = 24;
-
- lpBmInfoHdr->biBitCount = nBPP;
- lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight;
-}
-
-
+ // _fmemset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
+ memset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
+
+ lpBmInfoHdr->biSize = sizeof (BITMAPINFOHEADER);
+ lpBmInfoHdr->biWidth = dwWidth;
+ lpBmInfoHdr->biHeight = dwHeight;
+ lpBmInfoHdr->biPlanes = 1;
+
+ if (nBPP <= 1)
+ nBPP = 1;
+ else if (nBPP <= 4)
+ nBPP = 4;
+ else if (nBPP <= 8)
+ nBPP = 8;
+ /* Doesn't work
+ else if (nBPP <= 16)
+ nBPP = 16;
+ */
+ else
+ nBPP = 24;
+ lpBmInfoHdr->biBitCount = nBPP;
+ lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight;
+}
LPSTR wxFindDIBBits (LPSTR lpbi)
{
- return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi));
+ return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi));
}
-//---------------------------------------------------------------------
-//
-// Function: BitmapToDIB
-//
-// Purpose: Given a device dependent bitmap and a palette, returns
-// a handle to global memory with a DIB spec in it. The
-// DIB is rendered using the colors of the palette passed in.
-//
-// Stolen almost verbatim from ShowDIB.
-//
-// Parms: hBitmap == Handle to device dependent bitmap compatible
-// with default screen display device.
-// hPal == Palette to render the DDB with. If it's NULL,
-// use the default palette.
-//
-// History: Date Reason
-// 6/01/91 Created
-//
-//---------------------------------------------------------------------
+/*
+ * Function: BitmapToDIB
+ *
+ * Purpose: Given a device dependent bitmap and a palette, returns
+ * a handle to global memory with a DIB spec in it. The
+ * DIB is rendered using the colors of the palette passed in.
+ *
+ * Parms: hBitmap == Handle to device dependent bitmap compatible
+ * with default screen display device.
+ * hPal == Palette to render the DDB with. If it's NULL,
+ * use the default palette.
+ */
HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
{
- BITMAP Bitmap;
- BITMAPINFOHEADER bmInfoHdr;
- LPBITMAPINFOHEADER lpbmInfoHdr;
- LPSTR lpBits;
- HDC hMemDC;
- HANDLE hDIB;
- HPALETTE hOldPal = NULL;
-
- // Do some setup -- make sure the Bitmap passed in is valid,
- // get info on the bitmap (like its height, width, etc.),
- // then setup a BITMAPINFOHEADER.
+ BITMAP Bitmap;
+ BITMAPINFOHEADER bmInfoHdr;
+ LPBITMAPINFOHEADER lpbmInfoHdr;
+ LPSTR lpBits;
+ HDC hMemDC;
+ HANDLE hDIB;
+ HPALETTE hOldPal = NULL;
- if (!hBitmap)
- return NULL;
+ // Do some setup -- make sure the Bitmap passed in is valid,
+ // get info on the bitmap (like its height, width, etc.),
+ // then setup a BITMAPINFOHEADER.
- if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
- return NULL;
+ if (!hBitmap)
+ return NULL;
- InitBitmapInfoHeader (&bmInfoHdr,
- Bitmap.bmWidth,
- Bitmap.bmHeight,
- Bitmap.bmPlanes * Bitmap.bmBitsPixel);
+ if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
+ return NULL;
+ InitBitmapInfoHeader (&bmInfoHdr,
+ Bitmap.bmWidth,
+ Bitmap.bmHeight,
+ Bitmap.bmPlanes * Bitmap.bmBitsPixel);
- // Now allocate memory for the DIB. Then, set the BITMAPINFOHEADER
- // into this memory, and find out where the bitmap bits go.
+ // Now allocate memory for the DIB. Then, set the BITMAPINFOHEADER
+ // into this memory, and find out where the bitmap bits go.
- hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
- wxPaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
-
- if (!hDIB)
- return NULL;
-
-#ifdef __WINDOWS_386__
- lpbmInfoHdr = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock (hDIB));
-#else
- lpbmInfoHdr = (LPBITMAPINFOHEADER) GlobalLock (hDIB);
-#endif
-
- *lpbmInfoHdr = bmInfoHdr;
- lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr);
+ hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
+ wxPaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
+ if (!hDIB)
+ return NULL;
- // Now, we need a DC to hold our bitmap. If the app passed us
- // a palette, it should be selected into the DC.
+ lpbmInfoHdr = (LPBITMAPINFOHEADER) GlobalLock (hDIB);
- hMemDC = GetDC (NULL);
+ *lpbmInfoHdr = bmInfoHdr;
+ lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr);
- if (hPal)
- {
- hOldPal = SelectPalette (hMemDC, hPal, FALSE);
- RealizePalette (hMemDC);
- }
+ // Now, we need a DC to hold our bitmap. If the app passed us
+ // a palette, it should be selected into the DC.
+ hMemDC = GetDC (NULL);
- // We're finally ready to get the DIB. Call the driver and let
- // it party on our bitmap. It will fill in the color table,
- // and bitmap bits of our global memory block.
+ if (hPal)
+ {
+ hOldPal = SelectPalette (hMemDC, hPal, FALSE);
+ RealizePalette (hMemDC);
+ }
- if (!GetDIBits (hMemDC,
- hBitmap,
- 0,
- Bitmap.bmHeight,
- lpBits,
- (LPBITMAPINFO) lpbmInfoHdr,
- DIB_RGB_COLORS))
- {
- GlobalUnlock (hDIB);
- GlobalFree (hDIB);
- hDIB = NULL;
- }
- else
- GlobalUnlock (hDIB);
+ // We're finally ready to get the DIB. Call the driver and let
+ // it party on our bitmap. It will fill in the color table,
+ // and bitmap bits of our global memory block.
+ if (!GetDIBits (hMemDC, hBitmap, 0, Bitmap.bmHeight, lpBits,
+ (LPBITMAPINFO) lpbmInfoHdr, DIB_RGB_COLORS))
+ {
+ GlobalUnlock (hDIB);
+ GlobalFree (hDIB);
+ hDIB = NULL;
+ }
+ else
+ GlobalUnlock (hDIB);
- // Finally, clean up and return.
+ // Finally, clean up and return.
- if (hOldPal)
- SelectPalette (hMemDC, hOldPal, FALSE);
+ if (hOldPal)
+ SelectPalette (hMemDC, hOldPal, FALSE);
- ReleaseDC (NULL, hMemDC);
+ ReleaseDC (NULL, hMemDC);
- return hDIB;
+ return hDIB;
}
-bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)
+bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *palette)
{
- HPALETTE hPalette = 0;
+ HPALETTE hPalette = 0;
#if wxUSE_PALETTE
- if (colourmap)
- hPalette = (HPALETTE) colourmap->GetHPALETTE();
+ if (palette)
+ hPalette = (HPALETTE) palette->GetHPALETTE();
#endif // wxUSE_PALETTE
- HANDLE dibHandle = wxBitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
- if (dibHandle)
- {
- bool success = (WriteDIB(filename, dibHandle) != 0);
- GlobalFree(dibHandle);
- return success;
- }
- else return FALSE;
+ HANDLE dibHandle = wxBitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
+ if (dibHandle)
+ {
+ bool success = (wxWriteDIB(filename, dibHandle) != 0);
+ GlobalFree(dibHandle);
+ return success;
+ }
+ else return FALSE;
}
projects / wxWidgets.git / blobdiff