* *
* FUNCTIONS : *
* *
- * ReadDIB() - Reads a DIB *
+ * wxReadDIB() - Reads a DIB *
* *
* WriteDIB() - Writes a global handle in CF_DIB format*
* to a file. *
* *
- * PaletteSize() - Calculates the palette size in bytes *
+ * wxPaletteSize() - Calculates the palette size in bytes *
* of given DIB *
* *
* DibNumColors() - Determines the number of colors in DIB *
#include "wx/msw/dib.h"
+#ifndef __TWIN32__
+#ifndef wxUSE_NORLANDER_HEADERS
#ifdef __GNUWIN32__
#include "wx/msw/gnuwin32/extra.h"
#endif
+#endif
+#endif
#ifndef SEEK_CUR
/* flags for _lseek */
/* Header signatutes for various resources */
#define BFT_ICON 0x4349 /* 'IC' */
#define BFT_BITMAP 0x4d42 /* 'BM' */
-#define BFT_CURSOR 0x5450 /* 'PT' */
+#define BFT_CURSOR 0x5450 /* 'PT(' */
/* macro to determine if resource is a DIB */
#define ISDIB(bft) ((bft) == BFT_BITMAP)
#define PALVERSION 0x300
#define MAXPALETTE 256 /* max. # supported palette entries */
-DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
-DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
+static DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
+static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
-BOOL WriteDIB (LPSTR szFile,HANDLE hdib);
-WORD PaletteSize (VOID FAR * pv);
-WORD DibNumColors (VOID FAR * pv);
-// HANDLE DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
-BOOL PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
-HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER);
-BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
+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 *);
/****************************************************************************
* *
* *
****************************************************************************/
-BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
+static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
{
BITMAPFILEHEADER hdr;
LPBITMAPINFOHEADER lpbi;
if (!hdib)
return FALSE;
- fh = OpenFile(szFile, &of, OF_CREATE | OF_READWRITE);
+ fh = OpenFile(wxFNCONV(szFile), &of, OF_CREATE | OF_READWRITE);
if (fh == -1)
return FALSE;
hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
hdr.bfReserved1 = 0;
hdr.bfReserved2 = 0;
- hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
- PaletteSize(lpbi);
+ hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
+ wxPaletteSize(lpbi);
/* Write the file header */
_lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
/****************************************************************************
* *
- * FUNCTION : PaletteSize(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 *
* *
****************************************************************************/
-WORD PaletteSize(VOID FAR * pv)
+WORD wxPaletteSize(VOID FAR * pv)
{
LPBITMAPINFOHEADER lpbi;
WORD NumColors;
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
return NumColors * sizeof(RGBTRIPLE);
- else
+ else
return NumColors * sizeof(RGBQUAD);
}
* *
****************************************************************************/
-WORD DibNumColors(VOID FAR *pv)
+static WORD DibNumColors(VOID FAR *pv)
{
int bits;
BITMAPINFOHEADER *lpbi;
return (WORD) lpbi->biClrUsed;
bits = lpbi->biBitCount;
}
- else
+ else
bits = lpbc->bcBitCount;
switch (bits) {
****************************************************************************/
#if NOTHING
-HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
+static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
{
BITMAP bm;
BITMAPINFOHEADER bi;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
- dwLen = bi.biSize + PaletteSize(&bi);
+ dwLen = bi.biSize + wxPaletteSize(&bi);
- hdc = GetDC(NULL);
+ hdc = GetDC((HWND) NULL);
hpal = SelectPalette(hdc, hpal, FALSE);
RealizePalette(hdc);
}
/* realloc the buffer big enough to hold all the bits */
- dwLen = bi.biSize + PaletteSize(&bi) + bi.biSizeImage;
+ dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage;
if (h = GlobalReAlloc(hdib, dwLen, 0))
hdib = h;
else {
hbm,
0,
(WORD) bi.biHeight,
- (LPSTR) lpbi + (WORD) lpbi->biSize + PaletteSize(lpbi),
+ (LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi),
(LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
GlobalUnlock(hdib);
hdib = NULL;
SelectPalette(hdc, hpal, FALSE);
- ReleaseDC(NULL, hdc);
+ ReleaseDC((HWND) NULL, hdc);
return NULL;
}
* *
****************************************************************************/
-DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
+static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
{
DWORD ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
BYTE *hp = (BYTE *) pv;
#else
BYTE huge *hp = (BYTE huge *) pv;
* *
****************************************************************************/
-DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
+static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
{
DWORD ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
BYTE *hp = (BYTE *) pv;
#else
BYTE huge *hp = (BYTE huge *) pv;
* 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
+ * RETURNS : TRUE - DIB loaded and bitmap/palette created
* The DIBINIT structure pointed to by pInfo is
* filled with the appropriate handles.
* FALSE - otherwise
*
****************************************************************************/
-BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
+BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
{
int fh;
LPBITMAPINFOHEADER lpbi;
BITMAPFILEHEADER bf;
WORD nNumColors;
BOOL result = FALSE;
- char str[128];
+ wxChar str[128];
WORD offBits;
HDC hDC;
BOOL bCoreHead = FALSE;
/* Open the file and get a handle to it's BITMAPINFO */
- fh = OpenFile (lpFileName, &of, OF_READ);
+ fh = OpenFile (wxFNCONV(lpFileName), &of, OF_READ);
if (fh == -1) {
- wsprintf(str,"Can't open file '%ls'", (LPSTR)lpFileName);
- MessageBox(NULL, str, "Error", MB_ICONSTOP | MB_OK);
+ wsprintf(str,wxT("Can't open file '%s'"), lpFileName);
+ MessageBox(NULL, str, wxT("Error"), MB_ICONSTOP | MB_OK);
return (0);
}
-
- hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
+
+ hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
256 * sizeof(RGBQUAD)));
if (!hDIB)
return(0);
* lpbi->biHeight;
}
- /* get a proper-sized buffer for header, color table and bits */
+ /* get a proper-sized buffer for header, color table and bits */
GlobalUnlock(hDIB);
hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
nNumColors * sizeof(RGBQUAD) +
* to be used for a device-dependent representation of
* of the image.
*
- * RETURNS : TRUE --> success. phPal and phBitmap are filled with
+ * 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
*
****************************************************************************/
-BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
+static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
HPALETTE * phPal, HBITMAP * phBitmap)
{
LPBITMAPINFOHEADER lpInfo;
lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
#endif
- hPalette = MakeDIBPalette(lpInfo);
+ 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 +
+ lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
(WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
- hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
+ hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
(LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
SelectPalette(hDC, hOldPal, TRUE);
/****************************************************************************
* *
- * FUNCTION : MakeDIBPalette(lpInfo) *
+ * FUNCTION : wxMakeDIBPalette(lpInfo) *
* *
- * PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
+ * PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
* the color table.
- *
+ *
* *
- * RETURNS : non-zero - handle of a corresponding palette
+ * RETURNS : non-zero - handle of a corresponding palette
* zero - unable to create palette
* *
****************************************************************************/
-HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
+HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
{
- NPLOGPALETTE npPal;
+#ifdef __WXWINE__
+ return (FALSE);
+#else
+ LPLOGPALETTE npPal;
RGBQUAD far *lpRGB;
- HPALETTE hLogPal;
+ HPALETTE hLogPal;
WORD i;
/* since biClrUsed field was filled during the loading of the DIB,
if (lpInfo->biClrUsed)
{
/*
- npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
+ npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
(WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
*/
- npPal = (NPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
+ npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
(WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
-
if (!npPal)
return(FALSE);
hLogPal = CreatePalette((LPLOGPALETTE)npPal);
// LocalFree((HANDLE)npPal);
free(npPal);
-
+
return(hLogPal);
}
*/
else
return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
+#endif
+
}
-bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxPalette **pal)
+bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
{
HBITMAP hBitmap;
HPALETTE hPalette;
- bool success = (ReadDIB(filename, &hBitmap, &hPalette) != 0);
+ bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);
if (!success)
{
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(char *filename, wxPalette **pal)
+wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **pal)
{
wxBitmap *bitmap = new wxBitmap;
if (wxLoadIntoBitmap(filename, bitmap, pal))
//
// History: Date Reason
// 11/07/91 Created
-//
+//
//---------------------------------------------------------------------
-void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
+static void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
DWORD dwWidth,
DWORD dwHeight,
int nBPP)
-LPSTR FindDIBBits (LPSTR lpbi)
+LPSTR wxFindDIBBits (LPSTR lpbi)
{
- return (lpbi + *(LPDWORD)lpbi + PaletteSize (lpbi));
+ return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi));
}
//---------------------------------------------------------------------
//
// History: Date Reason
// 6/01/91 Created
-//
+//
//---------------------------------------------------------------------
-HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
+HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
{
BITMAP Bitmap;
BITMAPINFOHEADER bmInfoHdr;
if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
return NULL;
- InitBitmapInfoHeader (&bmInfoHdr,
- Bitmap.bmWidth,
- Bitmap.bmHeight,
+ 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.
- hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
- PaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
+ hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
+ wxPaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
if (!hDIB)
return NULL;
#endif
*lpbmInfoHdr = bmInfoHdr;
- lpBits = FindDIBBits ((LPSTR) lpbmInfoHdr);
+ lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr);
// Now, we need a DC to hold our bitmap. If the app passed us
// 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,
+ if (!GetDIBits (hMemDC,
+ hBitmap,
+ 0,
+ Bitmap.bmHeight,
+ lpBits,
+ (LPBITMAPINFO) lpbmInfoHdr,
DIB_RGB_COLORS))
{
GlobalUnlock (hDIB);
return hDIB;
}
-bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxPalette *colourmap)
+bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)
{
HPALETTE hPalette = 0;
if (colourmap)
hPalette = (HPALETTE) colourmap->GetHPALETTE();
- HANDLE dibHandle = BitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
+ HANDLE dibHandle = wxBitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
if (dibHandle)
{
bool success = (WriteDIB(filename, dibHandle) != 0);
projects / wxWidgets.git / blobdiff