// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Microsoft, Julian Smart and Markus Holzem
-// Licence: wxWindows license
+// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#endif
#ifndef WX_PRECOMP
-#include <stdio.h>
#include "wx/setup.h"
#include "wx/defs.h"
+#include "wx/string.h"
#endif
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
-#include <wx/msw/dibutils.h>
+
+#include "wx/msw/dibutils.h"
+
+#ifdef __WXWINE__
+ #include <module.h>
+#endif
#if defined(__WIN32__)
-#ifndef __MWERKS__
+#if !defined(__MWERKS__) && !defined(__SALFORDC__)
#include <memory.h> // for _fmemcpy()
#endif
- #define _huge
+ #define _huge
#ifndef hmemcpy
#define hmemcpy memcpy
#endif
#define BFT_ICON 0x4349 /* 'IC' */
#define BFT_BITMAP 0x4d42 /* 'BM' */
-#define BFT_CURSOR 0x5450 /* 'PT' */
+#define BFT_CURSOR 0x5450 /* 'PT(' */
+#ifndef SEEK_CUR
/* flags for _lseek */
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_SET 0
+#endif
+
+/* Copied from PNGhandler for coompilation with MingW32, RR */
+
+#ifndef GlobalAllocPtr
+#define GlobalPtrHandle(lp) \
+ ((HGLOBAL)GlobalHandle(lp))
+
+#define GlobalLockPtr(lp) \
+ ((BOOL)GlobalLock(GlobalPtrHandle(lp)))
+#define GlobalUnlockPtr(lp) \
+ GlobalUnlock(GlobalPtrHandle(lp))
+
+#define GlobalAllocPtr(flags, cb) \
+ (GlobalLock(GlobalAlloc((flags), (cb))))
+#define GlobalReAllocPtr(lp, cbNew, flags) \
+ (GlobalUnlockPtr(lp), GlobalLock(GlobalReAlloc(GlobalPtrHandle(lp) , (cbNew), (flags))))
+#define GlobalFreePtr(lp) \
+ (GlobalUnlockPtr(lp), (BOOL)GlobalFree(GlobalPtrHandle(lp)))
+#endif
/*
- * Clear the System Palette so that we can ensure an identity palette
+ * Clear the System Palette so that we can ensure an identity palette
* mapping for fast performance.
*/
-void ClearSystemPalette(void)
+void wxClearSystemPalette(void)
{
//*** A dummy palette setup
struct
UINT nMapped = 0;
BOOL bOK = FALSE;
int nOK = 0;
-
- //*** Reset everything in the system palette to black
+
+ // *** Reset everything in the system palette to black
for(Counter = 0; Counter < 256; Counter++)
{
Palette.aEntries[Counter].peRed = 0;
- Palette.aEntries[Counter].peGreen = 0;
+ Palette.aEntries[Counter].peGreen = 0;
Palette.aEntries[Counter].peBlue = 0;
Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
}
- //*** Create, select, realize, deselect, and delete the palette
+ // *** Create, select, realize, deselect, and delete the palette
+#ifdef __WXWINE__
+ ScreenDC = GetDC((HWND)NULL);
+#else
ScreenDC = GetDC(NULL);
+#endif
ScreenPalette = CreatePalette((LOGPALETTE *)&Palette);
if (ScreenPalette)
{
- ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
- nMapped = RealizePalette(ScreenDC);
+ ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
+ nMapped = RealizePalette(ScreenDC);
ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
bOK = DeleteObject(ScreenPalette);
}
+#ifdef __WXWINE__
+ nOK = ReleaseDC((HWND)NULL, ScreenDC);
+#else
nOK = ReleaseDC(NULL, ScreenDC);
+#endif
return;
}
* bits....
*/
-int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi)
+int wxDibWriteFile(LPTSTR szFile, LPBITMAPINFOHEADER lpbi)
{
- HFILE fh;
- OFSTRUCT of;
+ HFILE fh;
+ OFSTRUCT of;
- fh = OpenFile(szFile, &of, OF_WRITE | OF_CREATE);
+ fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_WRITE | OF_CREATE);
if (!fh) {
-// printf("la regamos0");
- return 0;
+// printf("la regamos0");
+ return 0;
}
- long size = DibSize(lpbi);
+ long size = wxDibSize(lpbi);
// write file header
BITMAPFILEHEADER bmf;
- bmf.bfType = 'BM';
+ bmf.bfType = BFT_BITMAP;
bmf.bfSize = sizeof(bmf) + size;
bmf.bfReserved1 = 0;
bmf.bfReserved2 = 0;
- bmf.bfOffBits = sizeof(bmf) + (char far*)(DibPtr(lpbi)) - (char far*)lpbi;
-#if defined( __WATCOMC__) || defined(_MSC_VER)
- if (_hwrite(fh, (LPCSTR)(&bmf), sizeof(bmf))<0 ||
- _hwrite(fh, (LPCSTR)lpbi, size)<0) {
- _lclose(fh);
-// printf("la regamos1");
- return 0;
- }
-#else
- if (_hwrite(fh, (LPBYTE)(&bmf), sizeof(bmf))<0 ||
- _hwrite(fh, (LPBYTE)lpbi, size)<0) {
- _lclose(fh);
-// printf("la regamos1");
- return 0;
- }
+ bmf.bfOffBits = sizeof(bmf) + (char FAR*)(wxDibPtr(lpbi)) - (char FAR*)lpbi;
+#if 1 // defined( __WATCOMC__) || defined(__VISUALC__) || defined(__SC__) || defined(__SALFORDC__) || defined(__MWERKS__) || wxUSE_NORLANDER_HEADERS
+ #define HWRITE_2ND_ARG_TYPE LPCSTR
+#else // don't know who needs this...
+ #define HWRITE_2ND_ARG_TYPE LPBYTE
#endif
+ if ( _hwrite(fh, (HWRITE_2ND_ARG_TYPE)(&bmf), sizeof(bmf)) < 0 ||
+ _hwrite(fh, (HWRITE_2ND_ARG_TYPE)lpbi, size) < 0 )
+ {
+ _lclose(fh);
+ return 0;
+ }
+
+#undef HWRITE_2ND_ARG_TYPE
+
_lclose(fh);
return 1;
}
-PDIB DibOpenFile(LPSTR szFile)
+PDIB wxDibOpenFile(LPTSTR szFile)
{
- HFILE fh;
- DWORD dwLen;
- DWORD dwBits;
- PDIB pdib;
- LPVOID p;
- OFSTRUCT of;
+ HFILE fh;
+ DWORD dwLen;
+ DWORD dwBits;
+ PDIB pdib;
+ LPVOID p;
+ OFSTRUCT of;
#if defined(WIN32) || defined(_WIN32)
- #define GetCurrentInstance() GetModuleHandle(NULL)
+ #define GetCurrentInstance() GetModuleHandle(NULL)
#else
- #define GetCurrentInstance() (HINSTANCE)SELECTOROF((LPVOID)&of)
+ #define GetCurrentInstance() (HINSTANCE)SELECTOROF((LPVOID)&of)
#endif
- fh = OpenFile(szFile, &of, OF_READ);
+ fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_READ);
- if (fh == -1)
- {
- HRSRC h;
+ if (fh == -1)
+ {
+ HRSRC h;
// TODO: Unicode version
#ifdef __WIN16__
- h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
+ h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
+#elif wxUSE_UNICODE
+ h = FindResourceW(GetCurrentInstance(), szFile, RT_BITMAP);
#else
- h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);
+ h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);
#endif
#if defined(__WIN32__)
- //!!! can we call GlobalFree() on this? is it the right format.
- //!!! can we write to this resource?
- if (h)
- return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));
+ //!!! can we call GlobalFree() on this? is it the right format.
+ //!!! can we write to this resource?
+ if (h)
+ return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));
#else
- if (h)
- fh = AccessResource(GetCurrentInstance(), h);
+ if (h)
+ fh = AccessResource(GetCurrentInstance(), h);
#endif
- }
+ }
- if (fh == -1)
- return NULL;
+ if (fh == -1)
+ return NULL;
- pdib = DibReadBitmapInfo(fh);
+ pdib = wxDibReadBitmapInfo(fh);
- if (!pdib)
- return NULL;
+ if (!pdib)
+ return NULL;
/* How much memory do we need to hold the DIB */
dwBits = pdib->biSizeImage;
- dwLen = pdib->biSize + DibPaletteSize(pdib) + dwBits;
+ dwLen = pdib->biSize + wxDibPaletteSize(pdib) + dwBits;
/* Can we get more memory? */
- p = GlobalReAllocPtr(pdib,dwLen,0);
+ p = GlobalReAllocPtr(pdib,dwLen,0);
if (!p)
{
- GlobalFreePtr(pdib);
+ GlobalFreePtr(pdib);
pdib = NULL;
}
else
if (pdib)
{
- /* read in the bits */
- _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + DibPaletteSize(pdib), dwBits);
+ /* read in the bits */
+ _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + wxDibPaletteSize(pdib), dwBits);
}
_lclose(fh);
* bitmap formats, but will always return a "new" BITMAPINFO.
*/
-PDIB DibReadBitmapInfo(HFILE fh)
+PDIB wxDibReadBitmapInfo(HFILE fh)
{
DWORD off;
- HANDLE hbi = NULL;
int size;
int i;
int nNumColors;
off = _llseek(fh,0L,SEEK_CUR);
if (sizeof(bf) != _lread(fh,(LPSTR)&bf,sizeof(bf)))
- return FALSE;
+ return NULL;
/*
* do we have a RC HEADER?
}
if (sizeof(bi) != _lread(fh,(LPSTR)&bi,sizeof(bi)))
- return FALSE;
+ return NULL;
/*
* what type of bitmap info is this?
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = (DWORD)bc.bcWidth;
bi.biHeight = (DWORD)bc.bcHeight;
- bi.biPlanes = (UINT)bc.bcPlanes;
- bi.biBitCount = (UINT)bc.bcBitCount;
+ bi.biPlanes = (WORD)bc.bcPlanes;
+ bi.biBitCount = (WORD)bc.bcBitCount;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
break;
}
- nNumColors = DibNumColors(&bi);
+ nNumColors = wxDibNumColors(&bi);
#if 0
if (bi.biSizeImage == 0)
bi.biSizeImage = DibSizeImage(&bi);
if (bi.biClrUsed == 0)
- bi.biClrUsed = DibNumColors(&bi);
+ bi.biClrUsed = wxDibNumColors(&bi);
#else
- FixBitmapInfo(&bi);
+ wxFixBitmapInfo(&bi);
#endif
pdib = (PDIB)GlobalAllocPtr(GMEM_MOVEABLE,(LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));
*pdib = bi;
- pRgb = DibColors(pdib);
+ pRgb = wxDibColors(pdib);
if (nNumColors)
{
* in the passed palette
*/
-BOOL DibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
+BOOL wxDibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
{
PALETTEENTRY ape[256];
RGBQUAD FAR * pRgb;
if (!pdib)
return FALSE;
- nColors = DibNumColors(pdib);
-
- if (nColors == 3 && DibCompression(pdib) == BI_BITFIELDS)
+ nColors = wxDibNumColors(pdib);
+
+ if (nColors == 3 && wxDibCompression(pdib) == BI_BITFIELDS)
nColors = 0;
if (nColors > 0)
{
- pRgb = DibColors(pdib);
+ pRgb = wxDibColors(pdib);
switch (wUsage)
{
* given number of bits per pixel
*/
-PDIB DibCreate(int bits, int dx, int dy)
+PDIB wxDibCreate(int bits, int dx, int dy)
{
LPBITMAPINFOHEADER lpbi ;
DWORD dwSizeImage;
*pdw++ = 0x00000000; // 0000 black
*pdw++ = 0x00800000; // 0001 dark red
*pdw++ = 0x00008000; // 0010 dark green
- *pdw++ = 0x00808000; // 0011 mustard
+ *pdw++ = 0x00808000; // 0011 mustard
*pdw++ = 0x00000080; // 0100 dark blue
*pdw++ = 0x00800080; // 0101 purple
*pdw++ = 0x00008080; // 0110 dark turquoise
*pdw++ = 0x00808080; // 0111 dark gray
*pdw++ = 0x00FF0000; // 1001 red
*pdw++ = 0x0000FF00; // 1010 green
- *pdw++ = 0x00FFFF00; // 1011 yellow
+ *pdw++ = 0x00FFFF00; // 1011 yellow
*pdw++ = 0x000000FF; // 1100 blue
*pdw++ = 0x00FF00FF; // 1101 pink (magenta)
*pdw++ = 0x0000FFFF; // 1110 cyan
#define RLE_EOF 1
#define RLE_JMP 2
-static void xlatRle8(BYTE FAR *pb, DWORD dwSize, BYTE FAR *xlat)
+static void xlatRle8(BYTE FAR *pb, DWORD WXUNUSED(dwSize), BYTE FAR *xlat)
{
BYTE cnt;
BYTE b;
}
}
-static void xlatRle4(BYTE FAR *pb, DWORD dwSize, BYTE FAR *xlat)
+static void xlatRle4(BYTE FAR *WXUNUSED(pb), DWORD WXUNUSED(dwSize), BYTE FAR *WXUNUSED(xlat))
{
}
* the colors of the given palette.
*/
-BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal)
+BOOL wxDibMapToPalette(PDIB pdib, HPALETTE hpal)
{
- LPBITMAPINFOHEADER lpbi;
- PALETTEENTRY pe;
- int n;
- int nDibColors;
- int nPalColors=0;
- BYTE FAR * lpBits;
- RGBQUAD FAR * lpRgb;
- BYTE xlat[256];
- DWORD SizeImage;
-
- if (!hpal || !pdib)
- return FALSE;
-
- lpbi = (LPBITMAPINFOHEADER)pdib;
- lpRgb = DibColors(pdib);
-
- GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
- nDibColors = DibNumColors(pdib);
-
- if ((SizeImage = lpbi->biSizeImage) == 0)
- SizeImage = DibSizeImage(lpbi);
-
- //
- // build a xlat table. from the current DIB colors to the given
- // palette.
- //
- for (n=0; n<nDibColors; n++)
- xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
-
- lpBits = (LPBYTE)DibPtr(lpbi);
- lpbi->biClrUsed = nPalColors;
-
- //
- // re-size the DIB
- //
- if (nPalColors > nDibColors)
- {
- GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
- hmemmove((BYTE _huge *)DibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
- lpBits = (LPBYTE)DibPtr(lpbi);
- }
- else if (nPalColors < nDibColors)
- {
- hmemcpy(DibPtr(lpbi), lpBits, SizeImage);
- GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
- lpBits = (LPBYTE)DibPtr(lpbi);
- }
-
- //
- // translate the DIB bits
- //
- switch (lpbi->biCompression)
- {
- case BI_RLE8:
- xlatRle8(lpBits, SizeImage, xlat);
- break;
-
- case BI_RLE4:
- xlatRle4(lpBits, SizeImage, xlat);
- break;
+ LPBITMAPINFOHEADER lpbi;
+ PALETTEENTRY pe;
+ int n;
+ int nDibColors;
+ int nPalColors=0;
+ BYTE FAR * lpBits;
+ RGBQUAD FAR * lpRgb;
+ BYTE xlat[256];
+ DWORD SizeImage;
+
+ if (!hpal || !pdib)
+ return FALSE;
+
+ lpbi = (LPBITMAPINFOHEADER)pdib;
+ lpRgb = wxDibColors(pdib);
+
+ GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
+ nDibColors = wxDibNumColors(pdib);
+
+ if ((SizeImage = lpbi->biSizeImage) == 0)
+ SizeImage = wxDibSizeImage(lpbi);
+
+ //
+ // build a xlat table. from the current DIB colors to the given
+ // palette.
+ //
+ for (n=0; n<nDibColors; n++)
+ xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
+
+ lpBits = (LPBYTE)wxDibPtr(lpbi);
+ lpbi->biClrUsed = nPalColors;
+
+ //
+ // re-size the DIB
+ //
+ if (nPalColors > nDibColors)
+ {
+ GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
+ hmemmove((BYTE _huge *)wxDibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
+ lpBits = (LPBYTE)wxDibPtr(lpbi);
+ }
+ else if (nPalColors < nDibColors)
+ {
+ hmemcpy(wxDibPtr(lpbi), lpBits, SizeImage);
+ GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
+ lpBits = (LPBYTE)wxDibPtr(lpbi);
+ }
+
+ //
+ // translate the DIB bits
+ //
+ switch (lpbi->biCompression)
+ {
+ case BI_RLE8:
+ xlatRle8(lpBits, SizeImage, xlat);
+ break;
+
+ case BI_RLE4:
+ xlatRle4(lpBits, SizeImage, xlat);
+ break;
case BI_RGB:
- if (lpbi->biBitCount == 8)
+ if (lpbi->biBitCount == 8)
xlatClut8(lpBits, SizeImage, xlat);
else
xlatClut4(lpBits, SizeImage, xlat);
GetPaletteEntries(hpal,n,1,&pe);
lpRgb[n].rgbRed = pe.peRed;
- lpRgb[n].rgbGreen = pe.peGreen;
- lpRgb[n].rgbBlue = pe.peBlue;
- lpRgb[n].rgbReserved = (BYTE)0;
- }
+ lpRgb[n].rgbGreen = pe.peGreen;
+ lpRgb[n].rgbBlue = pe.peBlue;
+ lpRgb[n].rgbReserved = (BYTE)0;
+ }
- return TRUE;
+ return TRUE;
}
-HPALETTE MakePalette(const BITMAPINFO FAR* Info, UINT flags)
+HPALETTE wxMakePalette(const BITMAPINFO FAR* Info, UINT flags)
{
HPALETTE hPalette;
- const RGBQUAD far* rgb = Info->bmiColors;
+ const RGBQUAD FAR* rgb = Info->bmiColors;
- WORD nColors = Info->bmiHeader.biClrUsed;
+ WORD nColors = (WORD)Info->bmiHeader.biClrUsed;
if (nColors) {
- LOGPALETTE* logPal = (LOGPALETTE*)
- new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
-
- logPal->palVersion = 0x300; // Windows 3.0 version
- logPal->palNumEntries = nColors;
- for (short n = 0; n < nColors; n++) {
- logPal->palPalEntry[n].peRed = rgb[n].rgbRed;
- logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
- logPal->palPalEntry[n].peBlue = rgb[n].rgbBlue;
- logPal->palPalEntry[n].peFlags = (BYTE)flags;
- }
- hPalette = ::CreatePalette(logPal);
- delete logPal;
+ LOGPALETTE* logPal = (LOGPALETTE*)
+ new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
+
+ logPal->palVersion = 0x300; // Windows 3.0 version
+ logPal->palNumEntries = nColors;
+ for (WORD n = 0; n < nColors; n++) {
+ logPal->palPalEntry[n].peRed = rgb[n].rgbRed;
+ logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
+ logPal->palPalEntry[n].peBlue = rgb[n].rgbBlue;
+ logPal->palPalEntry[n].peFlags = (BYTE)flags;
+ }
+ hPalette = ::CreatePalette(logPal);
+ delete logPal;
} else
- hPalette = 0;
+ hPalette = 0;
return hPalette;
}
projects / wxWidgets.git / blobdiff