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

Reverted wxFileSystem changes to image.cpp and dib.cpp

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@10575 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Kendall Bennett
2001-06-14 20:09:35 +00:00
parent 4a0b46a762
commit d80207c344
2 changed files with 580 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/common/image.cpp
View File

@@ -28,7 +28,6 @@
#include "wx/log.h" #include "wx/log.h"
#include "wx/app.h" #include "wx/app.h"
#include "wx/filefn.h" #include "wx/filefn.h"
#include "wx/filesys.h"
#include "wx/wfstream.h" #include "wx/wfstream.h"
#include "wx/intl.h" #include "wx/intl.h"
#include "wx/module.h" #include "wx/module.h"
@@ -230,12 +229,12 @@ wxImage wxImage::Scale( int width, int height ) const
for (long j = 0; j < height; j++) for (long j = 0; j < height; j++)
{ {
long y_offset = (j * (old_height-1) / (height-1)) * old_width; long y_offset = (j * old_height / height) * old_width;
for (long i = 0; i < width; i++) for (long i = 0; i < width; i++)
{ {
memcpy( target_data, memcpy( target_data,
source_data + 3*(y_offset + ((i * (old_width-1) )/ (width-1))), source_data + 3*(y_offset + ((i * old_width )/ width)),
3 ); 3 );
target_data += 3; target_data += 3;
} }
@@ -763,22 +762,18 @@ bool wxImage::HasOption(const wxString& name) const
bool wxImage::LoadFile( const wxString& filename, long type ) bool wxImage::LoadFile( const wxString& filename, long type )
{ {
#if wxUSE_STREAMS #if wxUSE_STREAMS
// We want to use wxFileSystem for virtual FS compatibility if (wxFileExists(filename))
wxFileSystem fsys;
wxFSFile *file = fsys.OpenFile(filename);
if (!file)
{ {
wxLogError(_("Can't open file '%s'"), filename.c_str()); wxFileInputStream stream(filename);
return FALSE; wxBufferedInputStream bstream( stream );
return LoadFile(bstream, type);
} }
wxInputStream *stream = file->GetStream(); else
if (!stream)
{ {
wxLogError(_("Can't open stream for file '%s'"), filename.c_str()); wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
return FALSE;
}
return LoadFile(*stream, type); return FALSE;
}
#else // !wxUSE_STREAMS #else // !wxUSE_STREAMS
return FALSE; return FALSE;
#endif // wxUSE_STREAMS #endif // wxUSE_STREAMS
@@ -787,21 +782,18 @@ bool wxImage::LoadFile( const wxString& filename, long type )
bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype ) bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype )
{ {
#if wxUSE_STREAMS #if wxUSE_STREAMS
// We want to use wxFileSystem for virtual FS compatibility if (wxFileExists(filename))
wxFileSystem fsys;
wxFSFile *file = fsys.OpenFile(filename);
if (!file)
{ {
wxLogError(_("Can't open file '%s'"), filename.c_str()); wxFileInputStream stream(filename);
wxBufferedInputStream bstream( stream );
return LoadFile(bstream, mimetype);
}
else
{
wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
return FALSE; return FALSE;
} }
wxInputStream *stream = file->GetStream();
if (!stream)
{
wxLogError(_("Can't open stream for file '%s'"), filename.c_str());
return FALSE;
}
return LoadFile(*stream, mimetype);
#else // !wxUSE_STREAMS #else // !wxUSE_STREAMS
return FALSE; return FALSE;
#endif // wxUSE_STREAMS #endif // wxUSE_STREAMS

524
src/msw/dib.cpp
View File

@@ -1,21 +1,29 @@
///////////////////////////////////////////////////////////////////////////// /*******************************************************************************
// Name: dib.cpp * *
// Purpose: Routines for dealing with Device Independent Bitmaps. * MODULE : DIB.CC *
// Author: * *
// Modified by: Jason Quijano 06/06/2001 * DESCRIPTION : Routines for dealing with Device Independent Bitmaps. *
// Created: 01/02/97 * *
// RCS-ID: $Id$ * FUNCTIONS : *
// Copyright: (c) Julian Smart * *
///////////////////////////////////////////////////////////////////////////// * wxReadDIB() - Reads a DIB *
// FUNCTIONS : * *
// wxReadDIB() - Reads a DIB * WriteDIB() - Writes a global handle in CF_DIB format*
// WriteDIB() - Writes a global handle in CF_DIB format to a file. * to a file. *
// wxPaletteSize() - Calculates the palette size in bytes of given DIB * * *
// DibNumColors() - Determines the number of colors in DIB * wxPaletteSize() - Calculates the palette size in bytes *
// DibFromBitmap() - Creates a DIB repr. the DDB passed in. * of given DIB *
// lread() - Private routine to read more than 64k * *
// lwrite() - Private routine to write more than 64k * 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". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
@@ -39,39 +47,39 @@
#endif #endif
#include "wx/msw/dib.h" #include "wx/msw/dib.h"
#include "wx/filesys.h"
#ifdef __GNUWIN32_OLD__ #ifdef __GNUWIN32_OLD__
#include "wx/msw/gnuwin32/extra.h" #include "wx/msw/gnuwin32/extra.h"
#endif #endif
#ifndef SEEK_CUR #ifndef SEEK_CUR
// flags for _lseek /* flags for _lseek */
#define SEEK_CUR 1 #define SEEK_CUR 1
#define SEEK_END 2 #define SEEK_END 2
#define SEEK_SET 0 #define SEEK_SET 0
#endif #endif
// Number of bytes to be read during each read operation. #define MAXREAD 32768 /* Number of bytes to be read during */
#define MAXREAD 32768 /* each read operation. */
// Header signatutes for various resources /* Header signatutes for various resources */
#define BFT_ICON 0x4349 // 'IC' #define BFT_ICON 0x4349 /* 'IC' */
#define BFT_BITMAP 0x4d42 // 'BM' #define BFT_BITMAP 0x4d42 /* 'BM' */
#define BFT_CURSOR 0x5450 // 'PT(' #define BFT_CURSOR 0x5450 /* 'PT(' */
// macro to determine if resource is a DIB /* macro to determine if resource is a DIB */
#define ISDIB(bft) ((bft) == BFT_BITMAP) #define ISDIB(bft) ((bft) == BFT_BITMAP)
// Macro to align given value to the closest DWORD (unsigned long ) /* Macro to align given value to the closest DWORD (unsigned long ) */
#define ALIGNULONG(i) ((i+3)/4*4) #define ALIGNULONG(i) ((i+3)/4*4)
// Macro to determine to round off the given value to the closest byte /* Macro to determine to round off the given value to the closest byte */
#define WIDTHBYTES(i) ((i+31)/32*4) #define WIDTHBYTES(i) ((i+31)/32*4)
#define PALVERSION 0x300 #define PALVERSION 0x300
#define MAXPALETTE 256 // max. # supported palette entries #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 PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
static BOOL WriteDIB (LPTSTR szFile,HANDLE hdib); static BOOL WriteDIB (LPTSTR szFile,HANDLE hdib);
@@ -80,14 +88,18 @@ static WORD DibNumColors (VOID FAR * pv);
// HANDLE DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal); // HANDLE DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
static BOOL PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *); 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. * FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
// RETURNS : TRUE - if successful. FALSE - otherwise * *
// ---------------------------------------------------------------------------- * PURPOSE : Write a global handle in CF_DIB format to a file. *
static BOOL WriteDIB( * *
LPTSTR szFile, * RETURNS : TRUE - if successful. *
HANDLE hdib ) * FALSE - otherwise *
* *
****************************************************************************/
static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
{ {
BITMAPFILEHEADER hdr; BITMAPFILEHEADER hdr;
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
@@ -96,6 +108,7 @@ static BOOL WriteDIB(
if (!hdib) if (!hdib)
return FALSE; return FALSE;
fh = OpenFile(wxConvertWX2MB(szFile), &of, OF_CREATE | OF_READWRITE); fh = OpenFile(wxConvertWX2MB(szFile), &of, OF_CREATE | OF_READWRITE);
if (fh == -1) if (fh == -1)
return FALSE; return FALSE;
@@ -105,17 +118,18 @@ static BOOL WriteDIB(
#else #else
lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib); lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
#endif #endif
// Fill in the fields of the file header /* Fill in the fields of the file header */
hdr.bfType = BFT_BITMAP; hdr.bfType = BFT_BITMAP;
hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER); hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
hdr.bfReserved1 = 0; hdr.bfReserved1 = 0;
hdr.bfReserved2 = 0; hdr.bfReserved2 = 0;
hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize + wxPaletteSize(lpbi); hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
wxPaletteSize(lpbi);
// Write the file header /* Write the file header */
_lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER)); _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
//Write the DIB header and the bits /* Write the DIB header and the bits */
lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib)); lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
GlobalUnlock(hdib); GlobalUnlock(hdib);
@@ -123,16 +137,20 @@ static BOOL WriteDIB(
return TRUE; return TRUE;
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : wxPaletteSize(VOID FAR * pv) * *
// PURPOSE : Calculates the palette size in bytes. If the info. block * FUNCTION : wxPaletteSize(VOID FAR * pv) *
// is of the BITMAPCOREHEADER type, the number of colors is * *
// multiplied by 3 to give the palette size, otherwise the * PURPOSE : Calculates the palette size in bytes. If the info. block *
// number of colors is multiplied by 4. * is of the BITMAPCOREHEADER type, the number of colors is *
// RETURNS : Palette size in number of bytes. * multiplied by 3 to give the palette size, otherwise the *
// ---------------------------------------------------------------------------- * number of colors is multiplied by 4. *
WORD wxPaletteSize( * *
VOID FAR * pv ) * RETURNS : Palette size in number of bytes. *
* *
****************************************************************************/
WORD wxPaletteSize(VOID FAR * pv)
{ {
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
WORD NumColors; WORD NumColors;
@@ -146,26 +164,31 @@ WORD wxPaletteSize(
return (WORD)(NumColors * sizeof(RGBQUAD)); return (WORD)(NumColors * sizeof(RGBQUAD));
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : DibNumColors(VOID FAR * pv) * *
// PURPOSE : Determines the number of colors in the DIB by looking at * FUNCTION : DibNumColors(VOID FAR * pv) *
// the BitCount filed in the info block. * *
// RETURNS : The number of colors in the DIB. * PURPOSE : Determines the number of colors in the DIB by looking at *
// ---------------------------------------------------------------------------- * the BitCount filed in the info block. *
static WORD DibNumColors( * *
VOID FAR *pv ) * RETURNS : The number of colors in the DIB. *
* *
****************************************************************************/
static WORD DibNumColors(VOID FAR *pv)
{ {
int bits; int bits;
BITMAPINFOHEADER *lpbi; BITMAPINFOHEADER *lpbi;
BITMAPCOREHEADER *lpbc; BITMAPCOREHEADER *lpbc;
lpbi = ((BITMAPINFOHEADER*) pv); lpbi = ((BITMAPINFOHEADER*) pv);
lpbc = ((BITMAPCOREHEADER*) pv); lpbc = ((BITMAPCOREHEADER*) pv);
// With the BITMAPINFO format headers, the size of the palette /* With the BITMAPINFO format headers, the size of the palette
// is in biClrUsed, whereas in the BITMAPCORE - style headers, it * is in biClrUsed, whereas in the BITMAPCORE - style headers, it
// is dependent on the bits per pixel ( = 2 raised to the power of * is dependent on the bits per pixel ( = 2 raised to the power of
// bits/pixel). * bits/pixel).
*/
if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) { if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
if (lpbi->biClrUsed != 0) if (lpbi->biClrUsed != 0)
return (WORD) lpbi->biClrUsed; return (WORD) lpbi->biClrUsed;
@@ -182,23 +205,24 @@ static WORD DibNumColors(
case 8: case 8:
return 256; return 256;
default: default:
// A 24 bitcount DIB has no color table /* A 24 bitcount DIB has no color table */
return 0; return 0;
} }
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : DibFromBitmap() * *
// PURPOSE : Will create a global memory block in DIB format that * FUNCTION : DibFromBitmap() *
// represents the Device-dependent bitmap (DDB) passed in. * *
// RETURNS : A handle to the DIB * 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 #if NOTHING
static HANDLE DibFromBitmap( static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
HBITMAP hbm,
DWORD biStyle,
WORD biBits,
HPALETTE hpal)
{ {
BITMAP bm; BITMAP bm;
BITMAPINFOHEADER bi; BITMAPINFOHEADER bi;
@@ -210,6 +234,7 @@ static HANDLE DibFromBitmap(
if (!hbm) if (!hbm)
return NULL; return NULL;
if (hpal == NULL) if (hpal == NULL)
hpal = GetStockObject(DEFAULT_PALETTE); hpal = GetStockObject(DEFAULT_PALETTE);
@@ -252,34 +277,39 @@ static HANDLE DibFromBitmap(
*lpbi = bi; *lpbi = bi;
// call GetDIBits with a NULL lpBits param, so it will calculate the /* call GetDIBits with a NULL lpBits param, so it will calculate the
// biSizeImage field for us * biSizeImage field for us
GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight, NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS); */
GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
bi = *lpbi; bi = *lpbi;
GlobalUnlock(hdib); GlobalUnlock(hdib);
// If the driver did not fill in the biSizeImage field, make one up /* If the driver did not fill in the biSizeImage field, make one up */
if (bi.biSizeImage == 0) { if (bi.biSizeImage == 0) {
bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight; bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
if (biStyle != BI_RGB) if (biStyle != BI_RGB)
bi.biSizeImage = (bi.biSizeImage * 3) / 2; bi.biSizeImage = (bi.biSizeImage * 3) / 2;
} }
// realloc the buffer big enough to hold all the bits /* realloc the buffer big enough to hold all the bits */
dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage; dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage;
if (h = GlobalReAlloc(hdib, dwLen, 0)) if (h = GlobalReAlloc(hdib, dwLen, 0))
hdib = h; hdib = h;
else { else {
GlobalFree(hdib); GlobalFree(hdib);
hdib = NULL; hdib = NULL;
SelectPalette(hdc, hpal, FALSE); SelectPalette(hdc, hpal, FALSE);
ReleaseDC(NULL, hdc); ReleaseDC(NULL, hdc);
return hdib; return hdib;
} }
// call GetDIBits with a NON-NULL lpBits param, and actualy get the /* call GetDIBits with a NON-NULL lpBits param, and actualy get the
// bits this time * bits this time
*/
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib)); lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
#else #else
@@ -301,23 +331,56 @@ static HANDLE DibFromBitmap(
bi = *lpbi; bi = *lpbi;
GlobalUnlock(hdib); GlobalUnlock(hdib);
SelectPalette(hdc, hpal, FALSE); SelectPalette(hdc, hpal, FALSE);
ReleaseDC(NULL, hdc); ReleaseDC(NULL, hdc);
return hdib; return hdib;
} }
#endif #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. *
* *
****************************************************************************/
//************* PRIVATE ROUTINES TO WRITE MORE THAN 64K ****************** static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
// ---------------------------------------------------------------------------- {
// FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) DWORD ulT = ul;
// PURPOSE : Writes data in steps of 32k till all the data is written. #if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
// RETURNS : 0 - If write did not proceed correctly. number of bytes written otherwise. BYTE *hp = (BYTE *) pv;
// ---------------------------------------------------------------------------- #else
static DWORD PASCAL lwrite( BYTE huge *hp = (BYTE huge *) pv;
int fh, #endif
VOID FAR *pv, while (ul > (DWORD) MAXREAD) {
DWORD ul) 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)
{ {
DWORD ulT = ul; DWORD ulT = ul;
#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__) #if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
@@ -336,23 +399,26 @@ static DWORD PASCAL lwrite(
return ulT; return ulT;
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : ReadDIB(hWnd) *
// PURPOSE : Reads a DIB from a file, obtains a handle to its * FUNCTION : ReadDIB(hWnd)
// BITMAPINFO struct. and loads the DIB. Once the DIB *
// is loaded, the function also creates a bitmap and * PURPOSE : Reads a DIB from a file, obtains a handle to its
// palette out of the DIB for a device-dependent form. * BITMAPINFO struct. and loads the DIB. Once the DIB
// RETURNS : TRUE - DIB loaded and bitmap/palette created * is loaded, the function also creates a bitmap and
// The DIBINIT structure pointed to by pInfo is * palette out of the DIB for a device-dependent form.
// filled with the appropriate handles. *
// FALSE - otherwise * RETURNS : TRUE - DIB loaded and bitmap/palette created
// ---------------------------------------------------------------------------- * The DIBINIT structure pointed to by pInfo is
BOOL wxReadDIB( * filled with the appropriate handles.
LPTSTR lpFileName, * FALSE - otherwise
HBITMAP *bitmap, *
HPALETTE *palette) ****************************************************************************/
BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
{ {
int fh;
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
OFSTRUCT of;
BITMAPFILEHEADER bf; BITMAPFILEHEADER bf;
WORD nNumColors; WORD nNumColors;
BOOL result = FALSE; BOOL result = FALSE;
@@ -361,17 +427,16 @@ BOOL wxReadDIB(
BOOL bCoreHead = FALSE; BOOL bCoreHead = FALSE;
HANDLE hDIB = 0; HANDLE hDIB = 0;
// JQ: We want to use wxFileSystem here in stead of Openfile so /* Open the file and get a handle to it's BITMAPINFO */
// that we can use other FS types like a zip files.
wxFileSystem fsys; fh = OpenFile (wxConvertWX2MB(lpFileName), &of, OF_READ);
wxFSFile *file = fsys.OpenFile(lpFileName); if (fh == -1) {
wxInputStream *dibs = file->GetStream();
if (!dibs) {
wxLogError(_("Can't open file '%s'"), lpFileName); wxLogError(_("Can't open file '%s'"), lpFileName);
return (0); return (0);
} }
hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD))); hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
256 * sizeof(RGBQUAD)));
if (!hDIB) if (!hDIB)
return(0); return(0);
@@ -381,22 +446,18 @@ BOOL wxReadDIB(
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
#endif #endif
// JQ: read from the wxInputStream dibs instead of fh so /* read the BITMAPFILEHEADER */
// that we can use other FS types like zip files. if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
dibs->Read((LPSTR)&bf,sizeof(bf));
if (sizeof(bf) != dibs->LastRead())
goto ErrExit; goto ErrExit;
if (bf.bfType != 0x4d42) // 'BM' if (bf.bfType != 0x4d42) /* 'BM' */
goto ErrExit; goto ErrExit;
// JQ: read from the wxInputStream dibs instead of fh so if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
// that we can use other FS types like zip files.
dibs->Read((LPSTR)lpbi,sizeof(BITMAPCOREHEADER));
if (sizeof(BITMAPCOREHEADER) != dibs->LastRead())
goto ErrExit; goto ErrExit;
if (lpbi->biSize == sizeof(BITMAPCOREHEADER)){ if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
{
lpbi->biSize = sizeof(BITMAPINFOHEADER); lpbi->biSize = sizeof(BITMAPINFOHEADER);
lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount; lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes; lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
@@ -404,46 +465,38 @@ BOOL wxReadDIB(
lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth; lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
bCoreHead = TRUE; bCoreHead = TRUE;
} }
else { else
{
// JQ: Get to the start of the header and read INFOHEADER // get to the start of the header and read INFOHEADER
// using dibs wxInputStream _llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);
dibs->SeekI(sizeof(BITMAPFILEHEADER),wxFromStart); if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
if (dibs->LastError() != wxSTREAM_NO_ERROR)
goto ErrExit; goto ErrExit;
// JQ: read from the wxInputStream dibs instead of fh so
// that we can use other FS types like zip files.
// Can I do error checking with this?
dibs->Read((LPSTR)lpbi,sizeof(BITMAPINFOHEADER));
if (sizeof(BITMAPINFOHEADER) != dibs->LastRead())
goto ErrExit;
} }
nNumColors = (WORD)lpbi->biClrUsed; nNumColors = (WORD)lpbi->biClrUsed;
if ( nNumColors == 0 ) { if ( nNumColors == 0 )
// no color table for 24-bit, default size otherwise {
/* no color table for 24-bit, default size otherwise */
if (lpbi->biBitCount != 24) if (lpbi->biBitCount != 24)
nNumColors = 1 << lpbi->biBitCount; // standard size table 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) if (lpbi->biClrUsed == 0)
lpbi->biClrUsed = nNumColors; lpbi->biClrUsed = nNumColors;
if (lpbi->biSizeImage == 0){ if (lpbi->biSizeImage == 0)
{
lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3) 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 /* get a proper-sized buffer for header, color table and bits */
GlobalUnlock(hDIB); GlobalUnlock(hDIB);
hDIB = GlobalReAlloc(hDIB, lpbi->biSize + nNumColors * sizeof(RGBQUAD) + hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
nNumColors * sizeof(RGBQUAD) +
lpbi->biSizeImage, 0); lpbi->biSizeImage, 0);
if (!hDIB) /* can't resize buffer for loading */
// can't resize buffer for loading
if (!hDIB)
goto ErrExit2; goto ErrExit2;
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
@@ -452,17 +505,21 @@ BOOL wxReadDIB(
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
#endif #endif
// read the color table /* read the color table */
if (!bCoreHead) if (!bCoreHead)
dibs->Read((LPSTR)lpbi + lpbi->biSize, nNumColors * sizeof(RGBQUAD)); _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
else { else
{
signed int i; signed int i;
RGBQUAD FAR *pQuad; RGBQUAD FAR *pQuad;
RGBTRIPLE FAR *pTriple; RGBTRIPLE FAR *pTriple;
dibs->Read((LPSTR)lpbi + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
_lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize); pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
pTriple = (RGBTRIPLE FAR *) pQuad; pTriple = (RGBTRIPLE FAR *) pQuad;
for (i = nNumColors - 1; i >= 0; i--){ for (i = nNumColors - 1; i >= 0; i--)
{
pQuad[i].rgbRed = pTriple[i].rgbtRed; pQuad[i].rgbRed = pTriple[i].rgbtRed;
pQuad[i].rgbBlue = pTriple[i].rgbtBlue; pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
pQuad[i].rgbGreen = pTriple[i].rgbtGreen; pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
@@ -470,18 +527,21 @@ BOOL wxReadDIB(
} }
} }
// offset to the bits from start of DIB header /* offset to the bits from start of DIB header */
offBits = (WORD)(lpbi->biSize + nNumColors * sizeof(RGBQUAD)); offBits = (WORD)(lpbi->biSize + nNumColors * sizeof(RGBQUAD));
if (bf.bfOffBits != 0L) if (bf.bfOffBits != 0L)
dibs->SeekI(bf.bfOffBits, wxFromStart); {
_llseek(fh,bf.bfOffBits,SEEK_SET);
}
dibs->Read((LPSTR)lpbi + offBits,lpbi->biSizeImage); if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
if (lpbi->biSizeImage == dibs->LastRead())
{ {
GlobalUnlock(hDIB); GlobalUnlock(hDIB);
hDC = GetDC(NULL); hDC = GetDC(NULL);
if (!MakeBitmapAndPalette(hDC, hDIB, palette, bitmap)) if (!MakeBitmapAndPalette(hDC, hDIB, palette,
bitmap))
{ {
ReleaseDC(NULL,hDC); ReleaseDC(NULL,hDC);
goto ErrExit2; goto ErrExit2;
@@ -500,23 +560,28 @@ ErrExit:
ErrExit2: ErrExit2:
GlobalFree(hDIB); GlobalFree(hDIB);
} }
_lclose(fh);
return(result); return(result);
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : MakeBitmapAndPalette *
// PURPOSE : Given a DIB, creates a bitmap and corresponding palette * FUNCTION : MakeBitmapAndPalette
// to be used for a device-dependent representation of *
// of the image. * PURPOSE : Given a DIB, creates a bitmap and corresponding palette
// RETURNS : TRUE --> success. phPal and phBitmap are filled with * to be used for a device-dependent representation of
// appropriate handles. Caller is responsible for freeing objects. * of the image.
// FALSE --> unable to create objects. both pointer are not valid *
// ---------------------------------------------------------------------------- * RETURNS : TRUE --> success. phPal and phBitmap are filled with
static BOOL PASCAL MakeBitmapAndPalette( * appropriate handles. Caller is responsible
HDC hDC, * for freeing objects.
HANDLE hDIB, * FALSE --> unable to create objects. both pointer are
HPALETTE * phPal, * not valid
HBITMAP * phBitmap) *
****************************************************************************/
static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
HPALETTE * phPal, HBITMAP * phBitmap)
{ {
LPBITMAPINFOHEADER lpInfo; LPBITMAPINFOHEADER lpInfo;
BOOL result = FALSE; BOOL result = FALSE;
@@ -556,18 +621,23 @@ static BOOL PASCAL MakeBitmapAndPalette(
} }
GlobalUnlock (hDIB); // glt GlobalUnlock (hDIB); // glt
return(result); return(result);
} }
// ---------------------------------------------------------------------------- /****************************************************************************
// FUNCTION : wxMakeDIBPalette(lpInfo) * *
// PURPOSE : Given a BITMAPINFOHEADER, create a palette based on * FUNCTION : wxMakeDIBPalette(lpInfo) *
// the color table. * *
// RETURNS : non-zero - handle of a corresponding palette * PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
// zero - unable to create palette * the color table.
// ---------------------------------------------------------------------------- *
HPALETTE wxMakeDIBPalette( * *
LPBITMAPINFOHEADER lpInfo ) * RETURNS : non-zero - handle of a corresponding palette
* zero - unable to create palette
* *
****************************************************************************/
HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
{ {
#ifdef __WXWINE__ #ifdef __WXWINE__
return (FALSE); return (FALSE);
@@ -577,8 +647,9 @@ HPALETTE wxMakeDIBPalette(
HPALETTE hLogPal; HPALETTE hLogPal;
WORD i; WORD i;
// since biClrUsed field was filled during the loading of the DIB, /* 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) if (lpInfo->biClrUsed)
{ {
/* /*
@@ -593,10 +664,10 @@ HPALETTE wxMakeDIBPalette(
npPal->palVersion = 0x300; npPal->palVersion = 0x300;
npPal->palNumEntries = (WORD)lpInfo->biClrUsed; npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
// get pointer to the color table /* get pointer to the color table */
lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize); lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);
// copy colors from the color table to the LogPalette structure /* copy colors from the color table to the LogPalette structure */
for (i = 0; (DWORD)i < lpInfo->biClrUsed; i++, lpRGB++) for (i = 0; (DWORD)i < lpInfo->biClrUsed; i++, lpRGB++)
{ {
npPal->palPalEntry[i].peRed = lpRGB->rgbRed; npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
@@ -608,31 +679,27 @@ HPALETTE wxMakeDIBPalette(
hLogPal = CreatePalette((LPLOGPALETTE)npPal); hLogPal = CreatePalette((LPLOGPALETTE)npPal);
// LocalFree((HANDLE)npPal); // LocalFree((HANDLE)npPal);
free(npPal); free(npPal);
return(hLogPal); return(hLogPal);
} }
// 24-bit DIB with no color table. return default palette. Another /* 24-bit DIB with no color table. return default palette. Another
// option would be to create a 256 color "rainbow" palette to provide ** option would be to create a 256 color "rainbow" palette to provide
// some good color choices. ** some good color choices.
*/
else else
return((HPALETTE) GetStockObject(DEFAULT_PALETTE)); return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
#endif #endif
} }
// ---------------------------------------------------------------------------- bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)
// FUNCTION :
// PURPOSE :
// RETURNS :
// ----------------------------------------------------------------------------
bool wxLoadIntoBitmap(
wxChar *filename,
wxBitmap *bitmap,
wxPalette **pal)
{ {
HBITMAP hBitmap; HBITMAP hBitmap;
HPALETTE hPalette; HPALETTE hPalette;
bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0); bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);
if (!success) if (!success)
{ {
DeleteObject(hPalette); DeleteObject(hPalette);
@@ -669,14 +736,7 @@ bool wxLoadIntoBitmap(
else return FALSE; else return FALSE;
} }
// ---------------------------------------------------------------------------- wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **pal)
// FUNCTION :
// PURPOSE :
// RETURNS :
// ----------------------------------------------------------------------------
wxBitmap *wxLoadBitmap(
wxChar *filename,
wxPalette **pal)
{ {
wxBitmap *bitmap = new wxBitmap; wxBitmap *bitmap = new wxBitmap;
if (wxLoadIntoBitmap(filename, bitmap, pal)) if (wxLoadIntoBitmap(filename, bitmap, pal))
@@ -689,9 +749,12 @@ wxBitmap *wxLoadBitmap(
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// FUNCTION : InitBitmapInfoHeader //
// PURPOSE : Does a "standard" initialization of a BITMAPINFOHEADER, // Function: InitBitmapInfoHeader
// given the Width, Height, and Bits per Pixel for the DIB. //
// 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 // By standard, I mean that all the relevant fields are set
// to the specified values. biSizeImage is computed, the // to the specified values. biSizeImage is computed, the
@@ -703,7 +766,7 @@ wxBitmap *wxLoadBitmap(
// used (whichever is most appropriate for the specified // used (whichever is most appropriate for the specified
// nBPP). // nBPP).
// //
// PARMS : lpBmInfoHdr == Far pointer to a BITMAPINFOHEADER structure // Parms: lpBmInfoHdr == Far pointer to a BITMAPINFOHEADER structure
// to be filled in. // to be filled in.
// dwWidth == Width of DIB (not in Win 3.0 & 3.1, high // dwWidth == Width of DIB (not in Win 3.0 & 3.1, high
// word MUST be 0). // word MUST be 0).
@@ -715,8 +778,8 @@ wxBitmap *wxLoadBitmap(
// 11/07/91 Created // 11/07/91 Created
// //
//--------------------------------------------------------------------- //---------------------------------------------------------------------
static void InitBitmapInfoHeader (
LPBITMAPINFOHEADER lpBmInfoHdr, static void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
DWORD dwWidth, DWORD dwWidth,
DWORD dwHeight, DWORD dwHeight,
int nBPP) int nBPP)
@@ -746,17 +809,16 @@ static void InitBitmapInfoHeader (
lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight; lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight;
} }
// ----------------------------------------------------------------------------
// FUNCTION :
// PURPOSE :
// RETURNS :
// ----------------------------------------------------------------------------
LPSTR wxFindDIBBits (LPSTR lpbi) LPSTR wxFindDIBBits (LPSTR lpbi)
{ {
return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi)); return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi));
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
//
// Function: BitmapToDIB // Function: BitmapToDIB
// //
// Purpose: Given a device dependent bitmap and a palette, returns // Purpose: Given a device dependent bitmap and a palette, returns
@@ -774,9 +836,8 @@ LPSTR wxFindDIBBits (LPSTR lpbi)
// 6/01/91 Created // 6/01/91 Created
// //
//--------------------------------------------------------------------- //---------------------------------------------------------------------
HANDLE wxBitmapToDIB (
HBITMAP hBitmap, HANDLE wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
HPALETTE hPal)
{ {
BITMAP Bitmap; BITMAP Bitmap;
BITMAPINFOHEADER bmInfoHdr; BITMAPINFOHEADER bmInfoHdr;
@@ -820,8 +881,10 @@ HANDLE wxBitmapToDIB (
*lpbmInfoHdr = bmInfoHdr; *lpbmInfoHdr = bmInfoHdr;
lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr); lpBits = wxFindDIBBits ((LPSTR) lpbmInfoHdr);
// Now, we need a DC to hold our bitmap. If the app passed us // Now, we need a DC to hold our bitmap. If the app passed us
// a palette, it should be selected into the DC. // a palette, it should be selected into the DC.
hMemDC = GetDC (NULL); hMemDC = GetDC (NULL);
if (hPal) if (hPal)
@@ -830,9 +893,12 @@ HANDLE wxBitmapToDIB (
RealizePalette (hMemDC); RealizePalette (hMemDC);
} }
// We're finally ready to get the DIB. Call the driver and let // 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, // it party on our bitmap. It will fill in the color table,
// and bitmap bits of our global memory block. // and bitmap bits of our global memory block.
if (!GetDIBits (hMemDC, if (!GetDIBits (hMemDC,
hBitmap, hBitmap,
0, 0,
@@ -848,23 +914,18 @@ HANDLE wxBitmapToDIB (
else else
GlobalUnlock (hDIB); GlobalUnlock (hDIB);
// Finally, clean up and return. // Finally, clean up and return.
if (hOldPal) if (hOldPal)
SelectPalette (hMemDC, hOldPal, FALSE); SelectPalette (hMemDC, hOldPal, FALSE);
ReleaseDC (NULL, hMemDC); ReleaseDC (NULL, hMemDC);
return hDIB; return hDIB;
} }
// ---------------------------------------------------------------------------- bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)
// FUNCTION :
// PURPOSE :
// RETURNS :
// ----------------------------------------------------------------------------
bool wxSaveBitmap(
wxChar *filename,
wxBitmap *bitmap,
wxPalette *colourmap)
{ {
HPALETTE hPalette = 0; HPALETTE hPalette = 0;
if (colourmap) if (colourmap)
@@ -880,4 +941,3 @@ bool wxSaveBitmap(
else return FALSE; else return FALSE;
} }