Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Some code tidying; removing dibutils.cpp which

Browse Source 
doesn't seem to be used any more


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@19606 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Julian Smart
2003-03-18 15:08:21 +00:00
parent 0f48e3d518
commit 1cfa5d8e39
21 changed files with 576 additions and 1214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
distrib/msw/tmake/filelist.txt
View File

@@ -289,7 +289,6 @@ dde.cpp MSW LowLevel,Base
dialog.cpp MSW
dialup.cpp MSW LowLevel
dib.cpp MSW LowLevel
dibutils.cpp MSW
dir.cpp MSW Base
dirdlg.cpp MSW Win32Only,LowLevel
display.cpp MSW Win32Only,LowLevel
@@ -1292,7 +1291,6 @@ dcscreen.h MSWH
dde.h MSWH Base
dialog.h MSWH
dib.h MSWH
dibutils.h MSWH
dirdlg.h MSWH
dragimag.h MSWH
enhmeta.h MSWH Win32Only

6
docs/todo30.txt
View File

@@ -167,6 +167,12 @@ wxMiscellaneous
- wxLocale Extension (eg Currency)
- wxStreams review
- wxURL?
- a way to tell wxWindows to check for any non-portable usage,
for a given set of platforms. Sometimes you want to be able
to get away with non-portable usage, and sometimes not.
This is probably way too time-consuming to implement.
- In headers, don't silently omit contents if the features for this
header is switched off. Instead, emit an error message.
Version: $Id$

7
include/wx/msw/curico.h
View File

@@ -12,16 +12,11 @@
#ifndef _WX_CURICO_H_
#define _WX_CURICO_H_
HICON ReadIconFile( wxChar *szFileName, HINSTANCE hInst,
int *W = 0, int *H = 0);
HCURSOR ReadCursorFile( wxChar *szFileName, HINSTANCE hInst,
int *W = 0, int *H = 0, int *XHot = 0, int *YHot = 0);
HCURSOR IconToCursor( wxChar *szFileName, HINSTANCE hInst, int XHot, int YHot,
int *W = 0, int *H = 0);
HICON CursorToIcon( wxChar *szFileName, HINSTANCE hInst,
int *W = 0, int *H = 0);
HCURSOR MakeCursorFromBitmap(HINSTANCE hInst, HBITMAP hBitmap, POINT *pPoint);
HICON MakeIconFromBitmap(HINSTANCE hInst, HBITMAP hBitmap);
#endif

3
include/wx/msw/curicop.h
View File

@@ -24,8 +24,6 @@
#define IS_WIN30_DIB( lpbi) ((*(LPDWORD)( lpbi)) == sizeof( BITMAPINFOHEADER))
WORD DIBNumColors(LPSTR pv);
WORD PaletteSize(LPSTR lpbi);
struct tagCURFILEHEADER { WORD wReserved; // Always 0
WORD wResourceType; // 2 = cursor
@@ -48,7 +46,6 @@ struct tagCURFILERES {
typedef struct tagCURFILERES CURFILERES;
HANDLE ReadCur( LPTSTR szFileName, LPPOINT lpptHotSpot, int *W = 0, int *H = 0);
HBITMAP ColorDDBToMonoDDB( HBITMAP hbm);
HCURSOR MakeCursor( HANDLE hDIB, LPPOINT lpptHotSpot, HINSTANCE hInst);
struct tagICONFILEHEADER {

6
include/wx/msw/dib.h
View File

@@ -170,16 +170,16 @@ extern WXDLLEXPORT wxBitmap wxConvertDIBToBitmap(const LPBITMAPINFO pbi);
// the rest is defined in dib.cpp
// Save (device dependent) wxBitmap as a DIB
bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap = NULL);
bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *palette = NULL);
// Load device independent bitmap into device dependent bitmap
wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **colourmap = NULL);
wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **palette = NULL);
// Load into existing bitmap;
bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal = NULL);
HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal);
BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
bool wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
HANDLE wxReadDIB2(LPTSTR lpFileName);
LPSTR wxFindDIBBits (LPSTR lpbi);
HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo);

23
include/wx/msw/dibutils.h
View File

@@ -9,25 +9,8 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/***************************************************************************
(C) Copyright 1994 Microsoft Corp. All rights reserved.
You have a royalty-free right to use, modify, reproduce and
distribute the Sample Files (and/or any modified version) in
any way you find useful, provided that you agree that
Microsoft has no warranty obligations or liability for any
Sample Application Files which are modified.
**************************************************************************/
/***************************************************************************
Functions for handling Device Independent Bitmaps and clearing the
System Palette.
**************************************************************************/
#ifndef SAMPLES_UTILS_H
#define SAMPLES_UTILS_H
#ifndef _DIBUTILS_H
#define _DIBUTILS_H
#ifdef __GNUG__
#pragma interface "dibutils.h"
@@ -40,7 +23,6 @@ typedef HANDLE HDIB;
External function declarations
**************************************************************************/
void wxClearSystemPalette(void);
PDIB wxDibOpenFile(LPTSTR szFile);
int wxDibWriteFile(LPTSTR szFile, LPBITMAPINFOHEADER lpbi);
BOOL wxDibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage);
@@ -130,3 +112,4 @@ PDIB wxDibReadBitmapInfo(HFILE fh);
#endif
#endif
// _DIBUTILS_H

345
src/msw/curico.cpp
View File

@@ -35,50 +35,6 @@
#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. *
@@ -268,35 +224,6 @@ HICON MakeIcon( HANDLE hDIB, HINSTANCE hInst)
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 *
@@ -410,112 +337,6 @@ HANDLE ReadCur( wxChar *szFileName, LPPOINT lpptHotSpot, int *W, int *H)
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.*
@@ -628,29 +449,6 @@ HCURSOR MakeCursor( HANDLE hDIB, LPPOINT lpptHotSpot, HINSTANCE hInst)
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 *
@@ -698,70 +496,7 @@ WORD DIBNumColors ( LPSTR pv)
}
}
#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;
@@ -842,81 +577,3 @@ HCURSOR MakeCursorFromBitmap(HINSTANCE hInst, HBITMAP hBitmap, POINT *pPoint)
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;
}

503
src/msw/dib.cpp
View File

@@ -29,8 +29,21 @@
#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"
// ============================================================================
@@ -185,59 +198,19 @@ bool wxDIB::Create(const wxImage& image)
// 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 */
@@ -266,27 +239,22 @@ bool wxDIB::Create(const wxImage& image)
#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 *);
static WORD wxDibNumColors (VOID FAR * pv);
static bool wxMakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
/****************************************************************************
* *
* FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
* *
* PURPOSE : Write a global handle in CF_DIB format to a file. *
* *
* RETURNS : TRUE - if successful. *
* FALSE - otherwise *
* *
****************************************************************************/
/*
* FUNCTION : 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 WriteDIB(LPTSTR szFile, HANDLE hdib)
static bool wxWriteDIB(LPTSTR szFile, HANDLE hdib)
{
BITMAPFILEHEADER hdr;
LPBITMAPINFOHEADER lpbi;
@@ -300,11 +268,8 @@ static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
if (fh == -1)
return FALSE;
#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);
@@ -324,18 +289,14 @@ static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
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)
{
@@ -343,7 +304,7 @@ WORD wxPaletteSize(VOID FAR * pv)
WORD NumColors;
lpbi = (LPBITMAPINFOHEADER) pv;
NumColors = DibNumColors(lpbi);
NumColors = wxDibNumColors(lpbi);
if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
return (WORD)(NumColors * sizeof(RGBTRIPLE));
@@ -351,18 +312,14 @@ WORD wxPaletteSize(VOID FAR * pv)
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;
@@ -397,147 +354,14 @@ static WORD DibNumColors(VOID FAR *pv)
}
}
/****************************************************************************
* *
* 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
/*
* 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.
*/
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
/************* 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;
#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
@@ -556,18 +380,14 @@ static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
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. *
* *
****************************************************************************/
/*
* 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)
static DWORD lwrite(int fh, VOID FAR *pv, DWORD ul)
{
DWORD ulT = ul;
#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
@@ -586,32 +406,29 @@ static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
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
* 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)
*/
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 */
@@ -627,11 +444,7 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
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)))
@@ -686,11 +499,7 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
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)
@@ -727,7 +536,7 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
GlobalUnlock(hDIB);
hDC = GetDC(NULL);
if (!MakeBitmapAndPalette(hDC, hDIB, palette,
if (!wxMakeBitmapAndPalette(hDC, hDIB, palette,
bitmap))
{
ReleaseDC(NULL,hDC);
@@ -752,35 +561,28 @@ ErrExit2:
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 )
@@ -812,18 +614,14 @@ static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
return(result);
}
/****************************************************************************
* *
* FUNCTION : wxMakeDIBPalette(lpInfo) *
* *
/*
* FUNCTION : wxMakeDIBPalette(lpInfo)
* PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
* the color table.
*
* *
* RETURNS : non-zero - handle of a corresponding palette
* zero - unable to create palette
* *
****************************************************************************/
*/
HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
{
LPLOGPALETTE npPal;
@@ -832,14 +630,10 @@ HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
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));
if (!npPal)
@@ -861,15 +655,14 @@ HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
}
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));
@@ -933,36 +726,33 @@ wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **pal)
}
}
//---------------------------------------------------------------------
//
// 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,
@@ -994,33 +784,23 @@ static void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight;
}
LPSTR wxFindDIBBits (LPSTR 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)
{
@@ -1047,7 +827,6 @@ HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
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.
@@ -1057,11 +836,7 @@ HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
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);
@@ -1078,19 +853,12 @@ HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
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))
if (!GetDIBits (hMemDC, hBitmap, 0, Bitmap.bmHeight, lpBits,
(LPBITMAPINFO) lpbmInfoHdr, DIB_RGB_COLORS))
{
GlobalUnlock (hDIB);
GlobalFree (hDIB);
@@ -1099,7 +867,6 @@ HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
else
GlobalUnlock (hDIB);
// Finally, clean up and return.
if (hOldPal)
@@ -1110,18 +877,18 @@ HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
return hDIB;
}
bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)
bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *palette)
{
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);
bool success = (wxWriteDIB(filename, dibHandle) != 0);
GlobalFree(dibHandle);
return success;
}

55
src/msw/dibutils.cpp
View File

@@ -72,60 +72,6 @@
(GlobalUnlockPtr(lp), (BOOL)GlobalFree(GlobalPtrHandle(lp)))
#endif
/*
* Clear the System Palette so that we can ensure an identity palette
* mapping for fast performance.
*/
void wxClearSystemPalette(void)
{
//*** A dummy palette setup
struct
{
WORD Version;
WORD NumberOfEntries;
PALETTEENTRY aEntries[256];
} Palette =
{
0x300,
256
};
HPALETTE ScreenPalette = 0;
HDC ScreenDC;
int Counter;
UINT nMapped = 0;
BOOL bOK = FALSE;
int nOK = 0;
// *** 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].peBlue = 0;
Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
}
// *** Create, select, realize, deselect, and delete the palette
ScreenDC = GetDC(NULL);
ScreenPalette = CreatePalette((LOGPALETTE *)&Palette);
if (ScreenPalette)
{
ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
nMapped = RealizePalette(ScreenDC);
ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
bOK = DeleteObject(ScreenPalette);
}
nOK = ReleaseDC(NULL, ScreenDC);
return;
}
/*
* Open a DIB file and return a MEMORY DIB, a memory handle containing..
*
@@ -142,7 +88,6 @@ int wxDibWriteFile(LPTSTR szFile, LPBITMAPINFOHEADER lpbi)
fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_WRITE | OF_CREATE);
if (!fh) {
// printf("la regamos0");
return 0;
}

3
src/msw/files.lst
View File

@@ -191,7 +191,6 @@ ALL_SOURCES = \
msw/dialog.cpp \
msw/dialup.cpp \
msw/dib.cpp \
msw/dibutils.cpp \
msw/dir.cpp \
msw/dirdlg.cpp \
msw/dragimag.cpp \
@@ -562,7 +561,6 @@ ALL_HEADERS = \
msw/dde.h \
msw/dialog.h \
msw/dib.h \
msw/dibutils.h \
msw/dirdlg.h \
msw/dragimag.h \
msw/enhmeta.h \
@@ -895,7 +893,6 @@ GUIOBJS = \
dialog.o \
dialup.o \
dib.o \
dibutils.o \
dir.o \
dirdlg.o \
dragimag.o \

10
src/msw/gdiimage.cpp
View File

@@ -494,6 +494,16 @@ bool wxICOFileHandler::LoadIcon(wxIcon *icon,
HICON hicon = ReadIconFile((wxChar *)name.c_str(),
wxGetInstance(),
&size.x, &size.y);
HICON hIcon = 0;
HANDLE hDIB = 0;
// Read the icon DIB from file
if( (hDIB = ReadIcon((wxChar *)name.c_str(), &size.x, &size.y)) == (HANDLE) NULL)
return false;
// Create an icon from DIB
hicon = MakeIcon( hDIB, wxGetInstance());
GlobalFree( hDIB);
#endif // Win32/Win16
if ( (desiredWidth != -1 && desiredWidth != size.x) ||

7
src/msw/icon.cpp
View File

@@ -146,8 +146,7 @@ void wxIcon::CopyFromBitmap(const wxBitmap& bmp)
// delete the inverted mask bitmap we created as well
::DeleteObject(iconInfo.hbmMask);
#else // Win16
// there are some functions in curico.cpp which probably could be used
// here...
/*
// This probably doesn't work.
HBITMAP hBitmap = (HBITMAP) bmp.GetHBITMAP();
HICON hIcon = MakeIconFromBitmap((HINSTANCE) wxGetInstance(), hBitmap);
@@ -156,8 +155,8 @@ void wxIcon::CopyFromBitmap(const wxBitmap& bmp)
SetHICON((WXHICON)hIcon);
SetSize(bmp.GetWidth(), bmp.GetHeight());
}
// wxFAIL_MSG("Bitmap to icon conversion (including use of XPMs for icons) not implemented");
*/
wxFAIL_MSG("Bitmap to icon conversion (including use of XPMs for icons) not implemented");
#endif // Win32/16
#endif
}

3
src/msw/makefile.b32
View File

@@ -133,7 +133,6 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\dialog.obj \
$(MSWDIR)\dialup.obj \
$(MSWDIR)\dib.obj \
$(MSWDIR)\dibutils.obj \
$(MSWDIR)\dir.obj \
$(MSWDIR)\dirdlg.obj \
$(MSWDIR)\dragimag.obj \
@@ -774,8 +773,6 @@ $(MSWDIR)\dialup.obj: $(MSWDIR)\dialup.$(SRCSUFF)
$(MSWDIR)\dib.obj: $(MSWDIR)\dib.$(SRCSUFF)
$(MSWDIR)\dibutils.obj: $(MSWDIR)\dibutils.$(SRCSUFF)
$(MSWDIR)\dir.obj: $(MSWDIR)\dir.$(SRCSUFF)
$(MSWDIR)\dirdlg.obj: $(MSWDIR)\dirdlg.$(SRCSUFF)

3
src/msw/makefile.bcc
View File

@@ -246,7 +246,6 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\dialog.obj \
$(MSWDIR)\dialup.obj \
$(MSWDIR)\dib.obj \
$(MSWDIR)\dibutils.obj \
$(MSWDIR)\dir.obj \
$(MSWDIR)\dragimag.obj \
$(MSWDIR)\evtloop.obj \
@@ -394,8 +393,6 @@ $(MSWDIR)\dialup.obj: $(MSWDIR)\dialup.$(SRCSUFF)
$(MSWDIR)\dib.obj: $(MSWDIR)\dib.$(SRCSUFF)
$(MSWDIR)\dibutils.obj: $(MSWDIR)\dibutils.$(SRCSUFF)
$(MSWDIR)\dir.obj: $(MSWDIR)\dir.$(SRCSUFF)
$(MSWDIR)\dragimag.obj: $(MSWDIR)\dragimag.$(SRCSUFF)

1
src/msw/makefile.dos
View File

@@ -234,7 +234,6 @@ MSWOBJS1 = $(MSWDIR)\accel.obj \
$(MSWDIR)\dialog.obj \
$(MSWDIR)\dialup.obj \
$(MSWDIR)\dib.obj \
$(MSWDIR)\dibutils.obj \
$(MSWDIR)\dir.obj \
$(MSWDIR)\dragimag.obj \
$(MSWDIR)\evtloop.obj \

1
src/msw/makefile.g95
View File

@@ -311,7 +311,6 @@ MSWOBJS = \
$(MSWDIR)/dialog.$(OBJSUFF) \
$(MSWDIR)/dialup.$(OBJSUFF) \
$(MSWDIR)/dib.$(OBJSUFF) \
$(MSWDIR)/dibutils.$(OBJSUFF) \
$(MSWDIR)/dragimag.$(OBJSUFF) \
$(MSWDIR)/enhmeta.$(OBJSUFF) \
$(MSWDIR)/evtloop.$(OBJSUFF) \

2
src/msw/makefile.sc
View File

@@ -1,3 +1,4 @@
; Last change: JS 18 Mar 103 2:45 pm
# This file was automatically generated by tmake
@@ -219,7 +220,6 @@ MSWOBJS = $(MSWDIR)\accel.obj \
$(MSWDIR)\dialog.obj \
$(MSWDIR)\dialup.obj \
$(MSWDIR)\dib.obj \
$(MSWDIR)\dibutils.obj \
$(MSWDIR)\dir.obj \
$(MSWDIR)\dirdlg.obj \
$(MSWDIR)\dragimag.obj \

1
src/msw/makefile.vc
View File

@@ -300,7 +300,6 @@ MSWOBJS = $(MSWDIR)\$D\accel.obj \
$(MSWDIR)\$D\dialog.obj \
$(MSWDIR)\$D\dialup.obj \
$(MSWDIR)\$D\dib.obj \
$(MSWDIR)\$D\dibutils.obj \
$(MSWDIR)\$D\dir.obj \
$(MSWDIR)\$D\dirdlg.obj \
$(MSWDIR)\$D\display.obj \

4
src/msw/makefile.wat
View File

@@ -242,7 +242,6 @@ MSWOBJS = $(OUTPUTDIR)\accel.obj &
$(OUTPUTDIR)\dialog.obj &
$(OUTPUTDIR)\dialup.obj &
$(OUTPUTDIR)\dib.obj &
$(OUTPUTDIR)\dibutils.obj &
$(OUTPUTDIR)\dir.obj &
$(OUTPUTDIR)\dirdlg.obj &
$(OUTPUTDIR)\dragimag.obj &
@@ -465,9 +464,6 @@ $(OUTPUTDIR)\dialup.obj: $(MSWDIR)\dialup.cpp
$(OUTPUTDIR)\dib.obj: $(MSWDIR)\dib.cpp
*$(CXX) $(CXXFLAGS) $<
$(OUTPUTDIR)\dibutils.obj: $(MSWDIR)\dibutils.cpp
*$(CXX) $(CXXFLAGS) $<
$(OUTPUTDIR)\dir.obj: $(MSWDIR)\dir.cpp
*$(CXX) $(CXXFLAGS) $<

181
src/wxWindows.dsp
View File

@@ -2,8 +2,8 @@
# 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,
@@ -32,8 +32,6 @@ CFG=wxWindows - Win32 Debug
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "wxWindows - Win32 Release Unicode DLL"
@@ -48,10 +46,13 @@ RSC=rc.exe
# 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
@@ -74,17 +75,20 @@ LINK32=link.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"
@@ -99,8 +103,10 @@ LINK32=link.exe
# 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
@@ -122,8 +128,10 @@ LIB32=link.exe -lib
# 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
@@ -146,10 +154,13 @@ LIB32=link.exe -lib
# 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
@@ -172,17 +183,20 @@ LINK32=link.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"
@@ -197,8 +211,10 @@ LINK32=link.exe
# 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
@@ -220,8 +236,10 @@ LIB32=link.exe -lib
# 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
@@ -356,6 +374,12 @@ SOURCE=.\common\docview.cpp
# 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
@@ -384,6 +408,11 @@ SOURCE=.\common\event.cpp
# 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
@@ -712,6 +741,11 @@ SOURCE=.\common\txtstrm.cpp
# 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
@@ -762,24 +796,6 @@ SOURCE=.\common\zipstrm.cpp
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"
@@ -908,7 +924,6 @@ SOURCE=.\generic\treelay.cpp
SOURCE=.\generic\wizard.cpp
# End Source File
# End Group
# Begin Group "wxHTML Files"
@@ -993,18 +1008,44 @@ SOURCE=.\html\m_tables.cpp
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
@@ -1113,10 +1154,6 @@ SOURCE=.\msw\dib.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
@@ -1129,6 +1166,11 @@ SOURCE=.\msw\dragimag.cpp
# 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
@@ -1181,6 +1223,16 @@ SOURCE=.\msw\glcanvas.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 Source File
SOURCE=.\msw\helpbest.cpp
# End Source File
# Begin Source File
@@ -1411,51 +1463,6 @@ SOURCE=.\msw\wave.cpp
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"
@@ -1466,7 +1473,9 @@ SOURCE=.\msw\ole\uuid.cpp
# 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
@@ -1474,7 +1483,9 @@ 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
@@ -1482,7 +1493,9 @@ 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
@@ -1490,7 +1503,9 @@ 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
@@ -1498,7 +1513,9 @@ 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
@@ -1506,7 +1523,9 @@ 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
@@ -1514,7 +1533,9 @@ 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
@@ -1522,7 +1543,9 @@ 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
@@ -1530,7 +1553,9 @@ 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"
@@ -2496,7 +2521,6 @@ SOURCE=..\include\wx\zipstrm.h
SOURCE=..\include\wx\zstream.h
# End Source File
# End Group
# Begin Group "MSW"
@@ -2877,7 +2901,6 @@ SOURCE=..\include\wx\msw\window.h
SOURCE=..\include\wx\msw\winundef.h
# End Source File
# End Group
# Begin Group "Generic"
@@ -3042,7 +3065,6 @@ SOURCE=..\include\wx\generic\treectlg.h
SOURCE=..\include\wx\generic\wizard.h
# End Source File
# End Group
# Begin Group "HTML"
@@ -3099,7 +3121,6 @@ SOURCE=..\include\wx\html\m_templ.h
SOURCE=..\include\wx\html\winpars.h
# End Source File
# End Group
# End Group
# End Target