#include "wx/msw/curico.h"
#include "wx/string.h"
-//*****************************************************************************
-//* Function : ReadIconFile() *
-//* Purpose : Reads an icon resource file and creates an icon based on that *
-//* information. *
-//* Parameters : char *szFileName - The icon resource file. *
-//* Returns : A handle to an icon. The handle will be NULL if an icon cannot *
-//* be created for any reason. *
-//*****************************************************************************
-
-HICON ReadIconFile( wxChar *szFileName, HINSTANCE hInst, int *W, int *H)
-{ HICON hIcon;
- HANDLE hDIB;
-
- if( (hDIB = ReadIcon(szFileName, W, H)) == (HANDLE) NULL)
- // read the icon DIB from file
- return (HICON) NULL;
- hIcon = MakeIcon( hDIB, hInst); // create an icon from DIB
- GlobalFree( hDIB);
- return hIcon;
-}
-
-//*****************************************************************************
-//* Function : CursorToIcon() *
-//* Purpose : Reads a cursor resource file and creates an icon based on that *
-//* information. *
-//* Parameters : char *szFileName - The cursor resource file. *
-//* Returns : A handle to an icon. The handle will be NULL if an icon cannot *
-//* be created for any reason. *
-//* Comments : A cursor is monochrome. So, the resulting icon will also be *
-//* monochrome. *
-//*****************************************************************************
-
-HICON CursorToIcon( wxChar *szFileName, HINSTANCE hInst, int *W, int *H)
-{ HANDLE hDIB; // Handle to DIB memory
- HICON hIcon; // Handle to Icon
-
- if( (hDIB = ReadCur( szFileName, NULL, W, H)) == (HANDLE) NULL)
- // Read cursor DIB
- return (HICON) NULL;
- hIcon = MakeIcon( hDIB, hInst); // make icon from cursor DIB
- GlobalFree( hDIB);
- return hIcon;
-}
-
//*****************************************************************************
//* Function : ReadIcon() *
//* Purpose : Reads an icon resource file and extracts the DIB information. *
return hIcon;
}
-// **************************************************************************
-
-//*****************************************************************************
-//* Function : ReadCursorFile() *
-//* Purpose : Reads a cursor resource file and creates a cursor based on that*
-//* information. *
-//* Parameters : char *szFileName - The cursor resource file. *
-//* Returns : A handle to a cursor. The handle will be NULL if a cursor can't*
-//* be created for any reason. *
-//*****************************************************************************
-
-HCURSOR ReadCursorFile( wxChar *szFileName, HINSTANCE hInst, int *W, int *H,
- int *XHot, int *YHot)
-{ HANDLE hDIB; // Handle to DIB memory
- HCURSOR hCursor;
- POINT ptHotSpot;
-
- // read cur DIB from file
- if( (hDIB = ReadCur( szFileName, (LPPOINT )&ptHotSpot, W, H)) == (HANDLE) NULL)
- return (HCURSOR) NULL;
- hCursor = MakeCursor( hDIB, (LPPOINT )&ptHotSpot, hInst);//create cur from DIB
- if(XHot != 0)
- *XHot = ptHotSpot.x;
- if(YHot != 0)
- *YHot = ptHotSpot.y;
- GlobalFree( hDIB);
- return ( hCursor);
-}
-
//*****************************************************************************
//* Function : IconToCursor() *
//* Purpose : Reads an icon resource file and creates a cursor based on that *
return( hDIB);
}
-//*****************************************************************************
-//* Function : ColorDDBToMonoDDB() *
-//* Purpose : Converts a color bitmap to a monochrome bitmap. *
-//* Parameters : HBITMAP hbm - The color bitmap. *
-//* Returns : A handle to a monochrome bitmap. *
-//*****************************************************************************
-HBITMAP ColorDDBToMonoDDB ( HBITMAP hbm)
-{ BITMAP bm;
- BITMAPINFOHEADER bi;
- LPBITMAPINFOHEADER lpbi;
- DWORD dwLen;
- HANDLE hdib;
- HANDLE h;
- HDC hdc;
- HBITMAP hbmMono;
-
- GetObject( hbm, sizeof( bm), (LPSTR )&bm);
-
- bi.biSize = sizeof( BITMAPINFOHEADER); // size of this structure
- bi.biWidth = bm.bmWidth; // bitmap width in pixels
- bi.biHeight = bm.bmHeight; // bitmap height in pixels
- bi.biPlanes = 1; // # of planes always 1 for DIBs
- bi.biBitCount = bm.bmPlanes * bm.bmBitsPixel; // color bits per pixel
- bi.biCompression = BI_RGB; // no compression
- bi.biSizeImage = 0; // 0 means default size
- bi.biXPelsPerMeter = 0; // not used
- bi.biYPelsPerMeter = 0; // not used
- bi.biClrUsed = 0; // 0 means default colors
- bi.biClrImportant = 0; // 0 means defaults
-
- dwLen = bi.biSize + PaletteSize((LPSTR)&bi);
-
- hdc = GetDC( (HWND) NULL);
-
- hdib = GlobalAlloc( GHND, dwLen);
- if (hdib == (HANDLE) NULL)
- {
- ReleaseDC( (HWND) NULL, hdc);
- return (HBITMAP) NULL;
- }
-
-#ifdef __WINDOWS_386__
- lpbi = (LPBITMAPINFOHEADER )MK_FP32(GlobalLock( hdib));
-#else
- lpbi = (LPBITMAPINFOHEADER )GlobalLock( hdib);
-#endif
-
- *lpbi = bi;
-
- // Call GetDIBits with a NULL lpBits parameter; it will calculate
- // the biSizeImage field.
- 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 * bi.biBitCount) * bm.bmHeight;
-
- // Reallocate the buffer big enough to hold all the bits.
- dwLen = bi.biSize + PaletteSize((LPSTR)&bi) + bi.biSizeImage;
- if( (h = GlobalReAlloc( hdib, dwLen, 0)) != 0)
- hdib = h;
- else
- {
- GlobalFree( hdib);
- ReleaseDC( (HWND) NULL, hdc);
- return (HBITMAP) NULL;
- }
-
- // Call GetDIBits with a NON-NULL lpBits parameter, to actually
- // get the bits this time.
-
-#ifdef __WINDOWS_386__
- lpbi = (LPBITMAPINFOHEADER )MK_FP32(GlobalLock( hdib));
-#else
- lpbi = (LPBITMAPINFOHEADER )GlobalLock( hdib);
-#endif
-
- if( GetDIBits( hdc, hbm, 0, (WORD)bi.biHeight,
- (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize((LPSTR)lpbi),
- (LPBITMAPINFO)lpbi, DIB_RGB_COLORS) == 0)
- {
- GlobalUnlock( hdib);
- hdib = (HANDLE) NULL;
- ReleaseDC( (HWND) NULL, hdc);
- return (HBITMAP) NULL;
- }
-
- // Finally, create a monochrome DDB, and put the DIB into
- // it. SetDIBits does smart color conversion.
- hbmMono = CreateBitmap((WORD)lpbi->biWidth, (WORD)lpbi->biHeight, 1, 1, NULL);
- SetDIBits( hdc, hbmMono, (WORD)0, (WORD)lpbi->biHeight,
- (LPSTR)lpbi + (int )lpbi->biSize + PaletteSize((LPSTR)lpbi),
- (LPBITMAPINFO)lpbi, DIB_RGB_COLORS);
-
- bi = *lpbi;
- GlobalUnlock( hdib);
- GlobalFree( hdib);
-
- ReleaseDC((HWND) NULL, hdc);
- return hbmMono;
-}
-
//*****************************************************************************
//* Function : MakeCursor() *
//* Purpose : Creates a cursor based on the DIB info. returned by ReadCursor.*
return hCursor;
}
-//*****************************************************************************
-//* Function : PaletteSize() *
-//* Purpose : Calculates the palette size in bytes. If the info. block is of *
-//* the BITMAPCOREHEADER type, the number of colors is multiplied *
-//* by sizeof(RGBTRIPLE) to give the palette size, otherwise the *
-//* number of colors is multiplied by sizeof(RGBQUAD). *
-//* Parameters : LPSTR pv - pointer to the BITMAPINFOHEADER *
-//* Returns : The size of the palette. *
-//*****************************************************************************
-
-WORD PaletteSize( LPSTR pv)
-{ LPBITMAPINFOHEADER lpbi;
- WORD NumColors;
-
- lpbi = (LPBITMAPINFOHEADER )pv;
- NumColors = DIBNumColors((LPSTR )lpbi);
-
- if(lpbi->biSize == sizeof( BITMAPCOREHEADER)) // OS/2 style DIBs
- return (WORD)(NumColors * sizeof( RGBTRIPLE));
- else
- return (WORD)(NumColors * sizeof( RGBQUAD));
-}
-
//*****************************************************************************
//* Function : DIBNumColors() *
//* Purpose : This function calculates the number of colors in the DIB's *
}
}
-#if 0
-// ******************************************************************
-BOOL fGetXPixmap( BOOL fIsIcon, wxChar *szFileName, HINSTANCE hInst,
- char cData[], int &width, int &height)
-{ HDC hdc,
- hdcMemory;
- HBITMAP hbmp,
- holdbmp;
- int i,
- j,
- w,
- h;
- BYTE *s,
- cByte,
- cMask;
- COLORREF rgb;
- HCURSOR hIconOrCursor = fIsIcon ?
- IconToCursor( szFileName, hInst, 0, 0, &w, &h)
- : ReadCursorFile( szFileName, hInst, &w, &h, 0, 0);
- int sum;
-
- if(hIconOrCursor == 0)
- return FALSE;
-
- hdc = GetDC( GetDesktopWindow());
- hdcMemory = CreateCompatibleDC( hdc);
- hbmp = CreateCompatibleBitmap( hdc, w, h);
- holdbmp = SelectObject( hdcMemory, hbmp);
- PatBlt( hdcMemory, 0, 0, w, h, BLACKNESS); // or use WHITENESS??
- DrawIcon( hdcMemory, 0, 0, hIconOrCursor); //using HCURSOR with DrawIcon is OK
-
- // the data retrieval follows:
- width = w;
- height = h;
- for( j = 0, s = (BYTE *)cData ; j < h ; ++j)
- for( i = 0 ; i < w ; ++i, cMask >>= 1)
- {
- if( (i % 8) == 0)
- {
- cByte = 0;
- cMask = 0x80;
- }
- rgb = GetPixel( hdcMemory, i, j);
- sum = (int )(rgb & 0xFFL);
- sum += (int )((rgb & 0xFF00L) >> 8);
- sum += (int )((rgb & 0xFF0000L) >> 16);
- if(sum > 381)
- cByte = cByte | cMask;
- if( (i % 8) == 7)
- {
- *s = cByte;
- ++s;
- }
- }
- SelectObject( hdcMemory, holdbmp);
- DeleteDC( hdcMemory);
- ReleaseDC( GetDesktopWindow(), hdc);
- DestroyCursor( hIconOrCursor);
- DeleteObject( hbmp);
- return TRUE;
-}
-#endif
-
-// Added from scavenged internet code, JACS 23/6/95
+// Added JACS 23/6/95
HCURSOR MakeCursorFromBitmap(HINSTANCE hInst, HBITMAP hBitmap, POINT *pPoint)
{
HDC hDCColor, hDCMono;
return hNewCursor;
}
-/*
- * This doesn't work: just gives us a grey square. Ideas, anyone?
- */
-
-HICON MakeIconFromBitmap(HINSTANCE hInst, HBITMAP hBitmap)
-{
- HDC hDCColor, hDCMono;
- HDC hDC;
- HBITMAP hBmpOld;
- HBITMAP hAndBmp;
- HBITMAP hXorBmp;
- HICON hNewIcon;
- BITMAP bm;
- DWORD dwBytes;
- NPSTR andBits;
- NPSTR xorBits;
-
- hDC = GetDC((HWND) NULL);
- hDCColor = CreateCompatibleDC(hDC);
- hDCMono = CreateCompatibleDC(hDC);
- hAndBmp = CreateCompatibleBitmap(hDCMono, 32, 32);
- hXorBmp = CreateCompatibleBitmap(hDCMono, 32, 32);
-
- hBmpOld = (HBITMAP) SelectObject(hDCColor, hBitmap);
- SelectObject(hDCMono, hAndBmp);
- SetBkColor(hDCColor, RGB(191, 191, 191));
-
- BitBlt(hDCMono, 0, 0, 32, 32, hDCColor, 0, 0, SRCCOPY);
-
- // Now we have the AND Mask
-
- GetObject(hAndBmp, sizeof(BITMAP), (LPSTR) &bm);
- dwBytes = (bm.bmWidthBytes * bm.bmHeight);
- andBits = (NPSTR) LocalAlloc(LPTR, dwBytes);
- GetBitmapBits(hAndBmp, dwBytes, andBits);
-
- SelectObject(hDCMono, hXorBmp);
- SetBkColor(hDCColor, RGB(0, 0, 0));
-
- BitBlt(hDCMono, 0, 0, 32, 32, hDCColor, 0, 0, SRCCOPY);
-
- // Now we have the XOR Mask
-
- GetObject(hXorBmp, sizeof(BITMAP), (LPSTR) &bm);
- dwBytes = (bm.bmWidthBytes * bm.bmHeight);
- xorBits = (NPSTR) LocalAlloc(LPTR, dwBytes);
- GetBitmapBits(hXorBmp, dwBytes, xorBits);
-
- hNewIcon = CreateIcon(hInst, 1, 4, 32, 32, (unsigned char *)andBits, (unsigned char *)xorBits);
-
- SelectObject(hDCColor, hBmpOld);
- SelectObject(hDCMono, hBmpOld);
- DeleteDC(hDCColor);
- DeleteDC(hDCMono);
- DeleteObject(hAndBmp);
- DeleteObject(hXorBmp);
- ReleaseDC((HWND) NULL, hDC);
-#ifndef __WIN32__
-#ifdef STRICT
- LocalUnlock(LocalHandle((void NEAR*) andBits));
- LocalUnlock(LocalHandle((void NEAR*) xorBits));
- LocalFree(LocalHandle((void NEAR*) andBits));
- LocalFree(LocalHandle((void NEAR*) xorBits));
-#else
- LocalUnlock(LocalHandle((WORD) andBits));
- LocalUnlock(LocalHandle((WORD) xorBits));
- LocalFree(LocalHandle((WORD) andBits));
- LocalFree(LocalHandle((WORD) xorBits));
-#endif
-#else
- LocalUnlock(LocalHandle((LPCVOID) andBits));
- LocalUnlock(LocalHandle((LPCVOID) xorBits));
- LocalFree(LocalHandle((LPCVOID) andBits));
- LocalFree(LocalHandle((LPCVOID) xorBits));
-#endif
- return hNewIcon;
-}
-
#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"
// ============================================================================
// 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)
-{
- BITMAPFILEHEADER hdr;
- LPBITMAPINFOHEADER lpbi;
- int fh;
- OFSTRUCT of;
+static WORD wxDibNumColors (VOID FAR * pv);
+static bool wxMakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
- if (!hdib)
- return FALSE;
+/*
+ * FUNCTION : wxWriteDIB(LPSTR szFile,HANDLE hdib)
+ * PURPOSE : Write a global handle in CF_DIB format to a file.
+ * RETURNS : TRUE - if successful.
+ * FALSE - otherwise
+ */
- fh = OpenFile(wxConvertWX2MB(szFile), &of, OF_CREATE | OF_READWRITE);
- if (fh == -1)
- return FALSE;
+static bool wxWriteDIB(LPTSTR szFile, HANDLE hdib)
+{
+ BITMAPFILEHEADER hdr;
+ LPBITMAPINFOHEADER lpbi;
+ int fh;
+ OFSTRUCT of;
+
+ if (!hdib)
+ 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));
-
- GlobalUnlock(hdib);
- _lclose(fh);
- return TRUE;
+ lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
+
+ 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;
-
- lpbi = (LPBITMAPINFOHEADER) pv;
- NumColors = DibNumColors(lpbi);
-
- if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
- return (WORD)(NumColors * sizeof(RGBTRIPLE));
- else
- return (WORD)(NumColors * sizeof(RGBQUAD));
+ LPBITMAPINFOHEADER lpbi;
+ WORD NumColors;
+
+ lpbi = (LPBITMAPINFOHEADER) pv;
+ NumColors = wxDibNumColors(lpbi);
+
+ 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;
-
- lpbi = ((BITMAPINFOHEADER*) pv);
- lpbc = ((BITMAPCOREHEADER*) pv);
-
+ int bits;
+ BITMAPINFOHEADER *lpbi;
+ BITMAPCOREHEADER *lpbc;
+
+ 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 */
-
+
fh = OpenFile (wxConvertWX2MB(lpFileName), &of, OF_READ);
if (fh == -1) {
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);
-
-#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)))
goto ErrExit;
-
+
if (bf.bfType != 0x4d42) /* 'BM' */
goto ErrExit;
-
+
if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
goto ErrExit;
-
+
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
{
lpbi->biSize = sizeof(BITMAPINFOHEADER);
}
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 = (WORD)lpbi->biClrUsed;
if ( nNumColors == 0 )
{
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;
-
+
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)
_lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
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].rgbReserved = 0;
}
}
-
+
/* offset to the bits from start of DIB header */
offBits = (WORD)(lpbi->biSize + nNumColors * sizeof(RGBQUAD));
-
+
if (bf.bfOffBits != 0L)
{
_llseek(fh,bf.bfOffBits,SEEK_SET);
}
-
+
if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
{
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 )
{
// 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);
+ (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);
-
+
if (!hBitmap)
DeleteObject(hPalette);
else
result = TRUE;
}
}
-
- 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;
RGBQUAD far *lpRGB;
HPALETTE hLogPal;
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;
-
+
npPal->palVersion = 0x300;
npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
-
+
/* 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; (DWORD)i < lpInfo->biClrUsed; i++, lpRGB++)
{
npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
npPal->palPalEntry[i].peFlags = 0;
}
-
+
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)
+ HBITMAP hBitmap = NULL;
+ HPALETTE hPalette = NULL;
+
+ bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);
+
+ if (!success)
{
- *pal = new wxPalette;
- (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
+ if (hPalette)
+ DeleteObject(hPalette);
+ return FALSE;
}
- else
+
+ 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);
+ 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);
+ bitmap->SetOk(TRUE);
#endif // WXWIN_COMPATIBILITY_2
- return TRUE;
- }
- else return FALSE;
+ 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;
- }
+ 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.
-
- if (!hBitmap)
- return NULL;
-
- 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.
-
- 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);
-
-
- // 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);
-
- if (hPal)
- {
- hOldPal = SelectPalette (hMemDC, hPal, FALSE);
- RealizePalette (hMemDC);
- }
-
-
-
- // 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.
-
- if (hOldPal)
- SelectPalette (hMemDC, hOldPal, FALSE);
-
- ReleaseDC (NULL, hMemDC);
-
- return hDIB;
+ 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.
+
+ if (!hBitmap)
+ return NULL;
+
+ 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.
+
+ hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
+ wxPaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
+
+ if (!hDIB)
+ return NULL;
+
+ lpbmInfoHdr = (LPBITMAPINFOHEADER) GlobalLock (hDIB);
+
+ *lpbmInfoHdr = bmInfoHdr;
+ lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr);
+
+
+ // 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);
+
+ if (hPal)
+ {
+ hOldPal = SelectPalette (hMemDC, hPal, FALSE);
+ RealizePalette (hMemDC);
+ }
+
+ // 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.
+
+ if (hOldPal)
+ SelectPalette (hMemDC, hOldPal, FALSE);
+
+ ReleaseDC (NULL, hMemDC);
+
+ 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;
}
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=wxWindows - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
!IF "$(CFG)" == "wxWindows - Win32 Release Unicode DLL"
# PROP Intermediate_Dir "../ReleaseUnicodeDll"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MD /W4 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WXWINDLL_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MD /W4 /O2 /I "../lib/mswdllu" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "_USRDLL" /D "WIN32" /D "NDEBUG" /D WINVER=0x0400 /D "STRICT" /D "WXMAKINGDLL" /D "_UNICODE" /D "UNICODE" /Yu"wx/wxprec.h" /FD /c
+MTL=midl.exe
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+RSC=rc.exe
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /i "../include" /d "NDEBUG"
BSC32=bscmake.exe
# PROP Intermediate_Dir "../DebugUnicodeDll"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MDd /W4 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WXWINDLL_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MDd /W4 /Zi /Od /I "../lib/mswdllud" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "_USRDLL" /D "WIN32" /D "_DEBUG" /D WINVER=0x0400 /D "STRICT" /D "WXMAKINGDLL" /D "_UNICODE" /D "UNICODE" /Yu"wx/wxprec.h" /FD /c
+MTL=midl.exe
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+RSC=rc.exe
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /i "../include" /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /dll /debug /machine:I386 /pdbtype:sept /out:"../lib/wxmsw250ud.dll"
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /dll /debug /machine:I386 /out:"../lib/wxmsw250ud.dll" /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib advapi32.lib comdlg32.lib shell32.lib ole32.lib oleaut32.lib odbc32.lib uuid.lib rpcrt4.lib comctl32.lib wsock32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /nologo /version:2.5 /dll /machine:I386 /out:"../lib/wxmsw250ud.dll"
!ELSEIF "$(CFG)" == "wxWindows - Win32 Release Unicode"
# PROP Output_Dir "../lib"
# PROP Intermediate_Dir "../ReleaseUnicode"
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MD /W4 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MD /W4 /O2 /I "../lib/mswu" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "WIN32" /D "NDEBUG" /D WINVER=0x0400 /D "STRICT" /D "_UNICODE" /D "UNICODE" /Yu"wx/wxprec.h" /FD /c
+RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# PROP Output_Dir "../lib"
# PROP Intermediate_Dir "../DebugUnicode"
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MDd /W4 /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MDd /W4 /Zi /Od /I "../lib/mswud" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "WIN32" /D "_DEBUG" /D "__WXDEBUG__" /D WINVER=0x0400 /D "STRICT" /D "_UNICODE" /D "UNICODE" /Yu"wx/wxprec.h" /FD /c
+RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# PROP Intermediate_Dir "../ReleaseDll"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MD /W4 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WXWINDLL_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MD /W4 /O2 /I "../lib/mswdll" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "_USRDLL" /D "WIN32" /D "NDEBUG" /D WINVER=0x0400 /D "STRICT" /D "WXMAKINGDLL" /Yu"wx/wxprec.h" /FD /c
+MTL=midl.exe
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+RSC=rc.exe
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /i "../include" /d "NDEBUG"
BSC32=bscmake.exe
# PROP Intermediate_Dir "../DebugDll"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MDd /W4 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WXWINDLL_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MDd /W4 /Zi /Od /I "../lib/mswdlld" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "_USRDLL" /D "WIN32" /D "_DEBUG" /D WINVER=0x0400 /D "STRICT" /D "WXMAKINGDLL" /Yu"wx/wxprec.h" /FD /c
+MTL=midl.exe
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+RSC=rc.exe
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /i "../include" /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /dll /debug /machine:I386 /pdbtype:sept /out:"../lib/wxmsw250d.dll"
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /dll /debug /machine:I386 /out:"../lib/wxmsw250d.dll" /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib advapi32.lib comdlg32.lib shell32.lib ole32.lib oleaut32.lib odbc32.lib uuid.lib rpcrt4.lib comctl32.lib wsock32.lib winmm.lib ..\lib\jpegd.lib ..\lib\tiffd.lib ..\lib\pngd.lib ..\lib\regexd.lib ..\lib\zlibd.lib /nologo /version:2.5 /dll /machine:I386 /out:"../lib/wxmsw250d.dll"
!ELSEIF "$(CFG)" == "wxWindows - Win32 Release"
# PROP Output_Dir "../lib"
# PROP Intermediate_Dir "../Release"
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MD /W4 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MD /W4 /O2 /I "../lib/msw" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "WIN32" /D "NDEBUG" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /c
+RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# PROP Output_Dir "../lib"
# PROP Intermediate_Dir "../Debug"
# PROP Target_Dir ""
+CPP=cl.exe
# ADD BASE CPP /nologo /MDd /W4 /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MDd /W4 /Zi /Od /I "../lib/mswd" /I "../include" /I "./zlib" /I "./jpeg" /I "./png" /I "./regex" /I "./tiff" /D "WIN32" /D "_DEBUG" /D "__WXDEBUG__" /D WINVER=0x0400 /D "STRICT" /Yu"wx/wxprec.h" /FD /c
+RSC=rc.exe
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# End Source File
# Begin Source File
+SOURCE=.\common\dosyacc.c
+# ADD CPP /W1 /D "USE_DEFINE" /D "IDE_INVOKED"
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
SOURCE=.\common\dseldlg.cpp
# End Source File
# Begin Source File
# End Source File
# Begin Source File
+SOURCE=.\common\extended.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
SOURCE=.\common\fddlgcmn.cpp
# End Source File
# Begin Source File
# End Source File
# Begin Source File
+SOURCE=.\common\unzip.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
SOURCE=.\common\url.cpp
# End Source File
# Begin Source File
SOURCE=.\common\zstream.cpp
# End Source File
-
-# Begin Source File
-
-SOURCE=.\common\extended.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=.\common\unzip.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-
-# Begin Source File
-
-SOURCE=.\common\dosyacc.c
-# ADD CPP /W1 /D "USE_DEFINE" /D "IDE_INVOKED"
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
# End Group
# Begin Group "Generic Files"
SOURCE=.\generic\wizard.cpp
# End Source File
-
# End Group
# Begin Group "wxHTML Files"
SOURCE=.\html\winpars.cpp
# End Source File
-
# End Group
# Begin Group "MSW Files"
+# PROP Default_Filter ""
+# Begin Group "OLE Files"
+
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\msw\dummy.cpp
-# ADD CPP /Yc"wx/wxprec.h"
+SOURCE=.\msw\ole\access.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\automtn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\dataobj.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\dropsrc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\droptgt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\oleutils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\ole\uuid.cpp
# End Source File
+# End Group
# Begin Source File
SOURCE=.\msw\accel.cpp
# End Source File
# Begin Source File
-SOURCE=.\msw\dibutils.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\msw\dir.cpp
# End Source File
# Begin Source File
# End Source File
# Begin Source File
+SOURCE=.\msw\dummy.cpp
+# ADD CPP /Yc"wx/wxprec.h"
+# End Source File
+# Begin Source File
+
SOURCE=.\msw\enhmeta.cpp
# End Source File
# Begin Source File
# End Source File
# Begin Source File
+SOURCE=.\msw\gsocket.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=.\msw\gsockmsw.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
SOURCE=.\msw\helpbest.cpp
# End Source File
# Begin Source File
SOURCE=.\msw\window.cpp
# End Source File
-
-# Begin Source File
-
-SOURCE=.\msw\gsocket.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\gsockmsw.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-
-# Begin Group "OLE Files"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\msw\ole\access.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\automtn.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\dataobj.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\dropsrc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\droptgt.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\oleutils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\msw\ole\uuid.cpp
-# End Source File
-
-# End Group
# End Group
# Begin Group "Headers"
# Begin Source File
SOURCE=..\include\wx\msw\setup.h
+
!IF "$(CFG)" == "wxWindows - Win32 Release Unicode DLL"
+
# Begin Custom Build - Creating ..\lib\mswdllu\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswdllu\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Debug Unicode DLL"
+
# Begin Custom Build - Creating ..\lib\mswdllud\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswdllud\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Release Unicode"
+
# Begin Custom Build - Creating ..\lib\mswu\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswu\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Debug Unicode"
+
# Begin Custom Build - Creating ..\lib\mswud\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswud\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Release DLL"
+
# Begin Custom Build - Creating ..\lib\mswdll\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswdll\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Debug DLL"
+
# Begin Custom Build - Creating ..\lib\mswdlld\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswdlld\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Release"
+
# Begin Custom Build - Creating ..\lib\msw\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\msw\wx\setup.h
# End Custom Build
+
!ELSEIF "$(CFG)" == "wxWindows - Win32 Debug"
+
# Begin Custom Build - Creating ..\lib\mswd\wx\setup.h from $(InputPath)
InputPath=..\include\wx\msw\setup.h
copy "$(InputPath)" ..\lib\mswd\wx\setup.h
# End Custom Build
+
!ENDIF
+
# End Source File
# End Group
# Begin Group "Common"
SOURCE=..\include\wx\zstream.h
# End Source File
-
# End Group
# Begin Group "MSW"
SOURCE=..\include\wx\msw\winundef.h
# End Source File
-
# End Group
# Begin Group "Generic"
SOURCE=..\include\wx\generic\wizard.h
# End Source File
-
# End Group
# Begin Group "HTML"
SOURCE=..\include\wx\html\winpars.h
# End Source File
-
# End Group
# End Group
# End Target
projects / wxWidgets.git / commitdiff
