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

1. fixed (?) blitting bitmaps with mask

Browse Source 
2. fixed wxWindowBase compilation (oops)
3. fixed kbd handling in wxScrolledWindow under MSW


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5660 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2000-01-26 00:01:27 +00:00
parent d80cd92ae2
commit a58a12e9b7
5 changed files with 406 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/wincmn.cpp
View File

@@ -748,7 +748,7 @@ bool wxWindowBase::TransferDataToWindow()
if ( recurse ) if ( recurse )
{ {
if ( !child->TransferToWindow() ) if ( !child->TransferDataToWindow() )
{ {
// warning already given // warning already given
return FALSE; return FALSE;
@@ -780,7 +780,7 @@ bool wxWindowBase::TransferDataFromWindow()
if ( recurse ) if ( recurse )
{ {
if ( !child->TransferFromWindow() ) if ( !child->TransferDataFromWindow() )
{ {
// warning already given // warning already given
return FALSE; return FALSE;

65
src/generic/scrolwin.cpp
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
@@ -106,10 +106,11 @@ bool wxScrolledWindow::Create(wxWindow *parent,
m_yScrollLinesPerPage = 0; m_yScrollLinesPerPage = 0;
m_scaleX = 1.0; m_scaleX = 1.0;
m_scaleY = 1.0; m_scaleY = 1.0;
m_targetWindow = this; m_targetWindow = this;
return wxPanel::Create(parent, id, pos, size, style, name); // we need wxWANTS_CHARS to process arrows ourselves
return wxPanel::Create(parent, id, pos, size, style | wxWANTS_CHARS, name);
} }
wxScrolledWindow::~wxScrolledWindow() wxScrolledWindow::~wxScrolledWindow()
@@ -139,7 +140,7 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
(pixelsPerUnitX != m_xScrollPixelsPerLine) || (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
(pixelsPerUnitY != m_yScrollPixelsPerLine) (pixelsPerUnitY != m_yScrollPixelsPerLine)
); );
m_xScrollPixelsPerLine = pixelsPerUnitX; m_xScrollPixelsPerLine = pixelsPerUnitX;
m_yScrollPixelsPerLine = pixelsPerUnitY; m_yScrollPixelsPerLine = pixelsPerUnitY;
m_xScrollPosition = xPos; m_xScrollPosition = xPos;
@@ -179,12 +180,12 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
} }
#endif // Motif #endif // Motif
AdjustScrollbars(); AdjustScrollbars();
if (do_refresh && !noRefresh) if (do_refresh && !noRefresh)
m_targetWindow->Refresh(); m_targetWindow->Refresh();
#ifdef __WXMSW__ #ifdef __WXMSW__
// GRG: if this turns out to be really necessary, we could // GRG: if this turns out to be really necessary, we could
// at least move it to the above if { ... } so that it is // at least move it to the above if { ... } so that it is
@@ -245,7 +246,7 @@ void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
{ {
m_yScrollPosition += nScrollInc; m_yScrollPosition += nScrollInc;
} }
if (orient == wxHORIZONTAL) if (orient == wxHORIZONTAL)
{ {
if (m_xScrollingEnabled) if (m_xScrollingEnabled)
@@ -331,7 +332,7 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
if (orient == wxHORIZONTAL) if (orient == wxHORIZONTAL)
{ {
if (m_xScrollPixelsPerLine > 0) if (m_xScrollPixelsPerLine > 0)
{ {
int w, h; int w, h;
m_targetWindow->GetClientSize(&w, &h); m_targetWindow->GetClientSize(&w, &h);
@@ -351,16 +352,16 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
} }
else else
{ {
if (m_yScrollPixelsPerLine > 0) if (m_yScrollPixelsPerLine > 0)
{ {
int w, h; int w, h;
m_targetWindow->GetClientSize(&w, &h); m_targetWindow->GetClientSize(&w, &h);
int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine; int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 ); int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
if (noPositions < 0) if (noPositions < 0)
noPositions = 0; noPositions = 0;
if ( (m_yScrollPosition + nScrollInc) < 0 ) if ( (m_yScrollPosition + nScrollInc) < 0 )
nScrollInc = -m_yScrollPosition; // As -ve as we can go nScrollInc = -m_yScrollPosition; // As -ve as we can go
else if ( (m_yScrollPosition + nScrollInc) > noPositions ) else if ( (m_yScrollPosition + nScrollInc) > noPositions )
@@ -378,7 +379,7 @@ void wxScrolledWindow::AdjustScrollbars()
{ {
int w, h; int w, h;
m_targetWindow->GetClientSize(&w, &h); m_targetWindow->GetClientSize(&w, &h);
int oldXScroll = m_xScrollPosition; int oldXScroll = m_xScrollPosition;
int oldYScroll = m_yScrollPosition; int oldYScroll = m_yScrollPosition;
@@ -399,11 +400,11 @@ void wxScrolledWindow::AdjustScrollbars()
SetScrollPageSize(wxHORIZONTAL, noPagePositions); SetScrollPageSize(wxHORIZONTAL, noPagePositions);
} }
else else
{ {
m_xScrollPosition = 0; m_xScrollPosition = 0;
SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
} }
if (m_yScrollLines > 0) if (m_yScrollLines > 0)
{ {
// Calculate page size i.e. number of scroll units you get on the // Calculate page size i.e. number of scroll units you get on the
@@ -423,9 +424,9 @@ void wxScrolledWindow::AdjustScrollbars()
else else
{ {
m_yScrollPosition = 0; m_yScrollPosition = 0;
SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
} }
if (oldXScroll != m_xScrollPosition) if (oldXScroll != m_xScrollPosition)
{ {
if (m_xScrollingEnabled) if (m_xScrollingEnabled)
@@ -433,7 +434,7 @@ void wxScrolledWindow::AdjustScrollbars()
else else
m_targetWindow->Refresh(); m_targetWindow->Refresh();
} }
if (oldYScroll != m_yScrollPosition) if (oldYScroll != m_yScrollPosition)
{ {
if (m_yScrollingEnabled) if (m_yScrollingEnabled)
@@ -447,7 +448,7 @@ void wxScrolledWindow::AdjustScrollbars()
// automatically change the origin according to the scroll position. // automatically change the origin according to the scroll position.
void wxScrolledWindow::PrepareDC(wxDC& dc) void wxScrolledWindow::PrepareDC(wxDC& dc)
{ {
dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine, dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
-m_yScrollPosition * m_yScrollPixelsPerLine ); -m_yScrollPosition * m_yScrollPixelsPerLine );
dc.SetUserScale( m_scaleX, m_scaleY ); dc.SetUserScale( m_scaleX, m_scaleY );
} }
@@ -497,9 +498,9 @@ void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
*/ */
void wxScrolledWindow::Scroll( int x_pos, int y_pos ) void wxScrolledWindow::Scroll( int x_pos, int y_pos )
{ {
if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
((y_pos == -1) || (y_pos == m_yScrollPosition))) return; ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
int w, h; int w, h;
m_targetWindow->GetClientSize(&w, &h); m_targetWindow->GetClientSize(&w, &h);
@@ -507,7 +508,7 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
{ {
int old_x = m_xScrollPosition; int old_x = m_xScrollPosition;
m_xScrollPosition = x_pos; m_xScrollPosition = x_pos;
// Calculate page size i.e. number of scroll units you get on the // Calculate page size i.e. number of scroll units you get on the
// current client window // current client window
int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
@@ -517,16 +518,16 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
// the visible portion of it or if below zero // the visible portion of it or if below zero
m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition ); m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
m_xScrollPosition = wxMax( 0, m_xScrollPosition ); m_xScrollPosition = wxMax( 0, m_xScrollPosition );
m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE ); m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 ); m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
} }
if (y_pos != -1) if (y_pos != -1)
{ {
int old_y = m_yScrollPosition; int old_y = m_yScrollPosition;
m_yScrollPosition = y_pos; m_yScrollPosition = y_pos;
// Calculate page size i.e. number of scroll units you get on the // Calculate page size i.e. number of scroll units you get on the
// current client window // current client window
int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 ); int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
@@ -536,13 +537,13 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
// the visible portion of it or if below zero // the visible portion of it or if below zero
m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition ); m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
m_yScrollPosition = wxMax( 0, m_yScrollPosition ); m_yScrollPosition = wxMax( 0, m_yScrollPosition );
m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE ); m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine ); m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
} }
#ifdef __WXMAC__ #ifdef __WXMAC__
m_targetWindow->MacUpdateImmediately() ; m_targetWindow->MacUpdateImmediately() ;
#endif #endif

8
src/msw/bitmap.cpp
View File

@@ -582,15 +582,15 @@ wxMask::~wxMask()
// Create a mask from a mono bitmap (copies the bitmap). // Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap) bool wxMask::Create(const wxBitmap& bitmap)
{ {
wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
_T("can't create mask from invalid or not monochrome bitmap") );
if ( m_maskBitmap ) if ( m_maskBitmap )
{ {
::DeleteObject((HBITMAP) m_maskBitmap); ::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0; m_maskBitmap = 0;
} }
if (!bitmap.Ok() || bitmap.GetDepth() != 1)
{
return FALSE;
}
m_maskBitmap = (WXHBITMAP) CreateBitmap( m_maskBitmap = (WXHBITMAP) CreateBitmap(
bitmap.GetWidth(), bitmap.GetWidth(),
bitmap.GetHeight(), bitmap.GetHeight(),

35
src/msw/dc.cpp
View File

@@ -23,7 +23,6 @@
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
@@ -46,6 +45,8 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
#if wxUSE_COMMON_DIALOGS #if wxUSE_COMMON_DIALOGS
#if wxUSE_NORLANDER_HEADERS #if wxUSE_NORLANDER_HEADERS
#include <windows.h> #include <windows.h>
@@ -57,7 +58,7 @@
#include <print.h> #include <print.h>
#endif #endif
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject) IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// constants // constants
@@ -1254,7 +1255,7 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
const wxBitmap& bmp = source->m_selectedBitmap; const wxBitmap& bmp = source->m_selectedBitmap;
mask = bmp.GetMask(); mask = bmp.GetMask();
wxCHECK_MSG( bmp.Ok() && mask, FALSE, wxCHECK_MSG( bmp.Ok() && mask && mask->GetMaskBitmap(), FALSE,
_T("can't blit with mask without mask") ); _T("can't blit with mask without mask") );
} }
@@ -1288,16 +1289,24 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
if (useMask) if (useMask)
{ {
#ifdef __WIN32__ #ifdef __WIN32__
if ( ::MaskBlt(GetHdc(), xdest, ydest, HBITMAP hbmpMask = wxInvertMask((HBITMAP)mask->GetMaskBitmap());
(int)width, (int)height,
GetHdcOf(*source), xsrc, ysrc, // we want the part of the image corresponding to the mask to be
(HBITMAP) mask->GetMaskBitmap(), // transparent, i.e. do PATCOPY there and apply dwRop elsewhere
0, 0, MAKEROP4(SRCCOPY, PATCOPY)) != 0 ) const wxColour& colBg = m_backgroundBrush.GetColour();
{ HBRUSH hbrBg = (HBRUSH)::CreateSolidBrush(wxColourToRGB(colBg));
// Success HBRUSH hbrOld = (HBRUSH)::SelectObject(GetHdc(), hbrBg);
success = TRUE;
} success = ::MaskBlt(GetHdc(), xdest, ydest, width, height,
else GetHdcOf(*source), xsrc, ysrc,
hbmpMask, 0, 0,
MAKEROP4(PATCOPY, dwRop)) != 0;
(void)::SelectObject(GetHdc(), hbrOld);
::DeleteObject(hbrOld);
::DeleteObject(hbmpMask);
if ( !success )
#endif // Win32 #endif // Win32
{ {
// Blit bitmap with mask // Blit bitmap with mask

692
src/msw/dib.cpp
View File

@@ -1,28 +1,28 @@
/******************************************************************************* /*******************************************************************************
* * * *
* MODULE : DIB.CC * * MODULE : DIB.CC *
* * * *
* DESCRIPTION : Routines for dealing with Device Independent Bitmaps. * * DESCRIPTION : Routines for dealing with Device Independent Bitmaps. *
* * * *
* FUNCTIONS : * * FUNCTIONS : *
* * * *
* wxReadDIB() - Reads a DIB * * 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 * * wxPaletteSize() - Calculates the palette size in bytes *
* of given DIB * * of given DIB *
* * * *
* DibNumColors() - Determines the number of colors in DIB * * DibNumColors() - Determines the number of colors in DIB *
* * * *
* DibFromBitmap() - Creates a DIB repr. the DDB passed in. * * DibFromBitmap() - Creates a DIB repr. the DDB passed in. *
* * * *
* * * *
* lread() - Private routine to read more than 64k * * lread() - Private routine to read more than 64k *
* * * *
* lwrite() - Private routine to write 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".
@@ -58,64 +58,64 @@
#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
#define MAXREAD 32768 /* Number of bytes to be read during */ #define MAXREAD 32768 /* Number of bytes to be read during */
/* each read operation. */ /* 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 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);
WORD wxPaletteSize (VOID FAR * pv); // This is non-static as some apps use it externally WORD wxPaletteSize (VOID FAR * pv); // This is non-static as some apps use it externally
static WORD DibNumColors (VOID FAR * pv); 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) * * FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
* * * *
* PURPOSE : Write a global handle in CF_DIB format to a file. * * PURPOSE : Write a global handle in CF_DIB format to a file. *
* * * *
* RETURNS : TRUE - if successful. * * RETURNS : TRUE - if successful. *
* FALSE - otherwise * * FALSE - otherwise *
* * * *
****************************************************************************/ ****************************************************************************/
static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib) static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
{ {
BITMAPFILEHEADER hdr; BITMAPFILEHEADER hdr;
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
int fh; int fh;
OFSTRUCT of; OFSTRUCT of;
if (!hdib) if (!hdib)
return FALSE; return FALSE;
fh = OpenFile(wxFNCONV(szFile), &of, OF_CREATE | OF_READWRITE); fh = OpenFile(wxFNCONV(szFile), &of, OF_CREATE | OF_READWRITE);
if (fh == -1) if (fh == -1)
return FALSE; return FALSE;
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib)); lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));
@@ -123,284 +123,284 @@ static BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)
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 + hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
wxPaletteSize(lpbi); 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);
_lclose(fh); _lclose(fh);
return TRUE; return TRUE;
} }
/**************************************************************************** /****************************************************************************
* * * *
* FUNCTION : wxPaletteSize(VOID FAR * pv) * * FUNCTION : wxPaletteSize(VOID FAR * pv) *
* * * *
* PURPOSE : Calculates the palette size in bytes. If the info. block * * PURPOSE : Calculates the palette size in bytes. If the info. block *
* is of the BITMAPCOREHEADER type, the number of colors is * * is of the BITMAPCOREHEADER type, the number of colors is *
* multiplied by 3 to give the palette size, otherwise the * * multiplied by 3 to give the palette size, otherwise the *
* number of colors is multiplied by 4. * * number of colors is multiplied by 4. *
* * * *
* RETURNS : Palette size in number of bytes. * * RETURNS : Palette size in number of bytes. *
* * * *
****************************************************************************/ ****************************************************************************/
WORD wxPaletteSize(VOID FAR * pv) WORD wxPaletteSize(VOID FAR * pv)
{ {
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
WORD NumColors; WORD NumColors;
lpbi = (LPBITMAPINFOHEADER) pv; lpbi = (LPBITMAPINFOHEADER) pv;
NumColors = DibNumColors(lpbi); NumColors = DibNumColors(lpbi);
if (lpbi->biSize == sizeof(BITMAPCOREHEADER)) if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
return NumColors * sizeof(RGBTRIPLE); return NumColors * sizeof(RGBTRIPLE);
else else
return NumColors * sizeof(RGBQUAD); return NumColors * sizeof(RGBQUAD);
} }
/**************************************************************************** /****************************************************************************
* * * *
* FUNCTION : DibNumColors(VOID FAR * pv) * * FUNCTION : DibNumColors(VOID FAR * pv) *
* * * *
* PURPOSE : Determines the number of colors in the DIB by looking at * * PURPOSE : Determines the number of colors in the DIB by looking at *
* the BitCount filed in the info block. * * the BitCount filed in the info block. *
* * * *
* RETURNS : The number of colors in the DIB. * * RETURNS : The number of colors in the DIB. *
* * * *
****************************************************************************/ ****************************************************************************/
static WORD DibNumColors(VOID FAR *pv) 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;
bits = lpbi->biBitCount; bits = lpbi->biBitCount;
} }
else else
bits = lpbc->bcBitCount; bits = lpbc->bcBitCount;
switch (bits) { switch (bits) {
case 1: case 1:
return 2; return 2;
case 4: case 4:
return 16; return 16;
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() * * FUNCTION : DibFromBitmap() *
* * * *
* PURPOSE : Will create a global memory block in DIB format that * * PURPOSE : Will create a global memory block in DIB format that *
* represents the Device-dependent bitmap (DDB) passed in. * * represents the Device-dependent bitmap (DDB) passed in. *
* * * *
* RETURNS : A handle to the DIB * * RETURNS : A handle to the DIB *
* * * *
****************************************************************************/ ****************************************************************************/
#if NOTHING #if NOTHING
static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal) static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
{ {
BITMAP bm; BITMAP bm;
BITMAPINFOHEADER bi; BITMAPINFOHEADER bi;
BITMAPINFOHEADER FAR *lpbi; BITMAPINFOHEADER FAR *lpbi;
DWORD dwLen; DWORD dwLen;
HANDLE hdib; HANDLE hdib;
HANDLE h; HANDLE h;
HDC hdc; HDC hdc;
if (!hbm) if (!hbm)
return NULL; return NULL;
if (hpal == NULL) if (hpal == NULL)
hpal = GetStockObject(DEFAULT_PALETTE); hpal = GetStockObject(DEFAULT_PALETTE);
GetObject(hbm, sizeof (bm), (LPSTR) &bm); GetObject(hbm, sizeof (bm), (LPSTR) &bm);
if (biBits == 0) if (biBits == 0)
biBits = bm.bmPlanes * bm.bmBitsPixel; biBits = bm.bmPlanes * bm.bmBitsPixel;
bi.biSize = sizeof(BITMAPINFOHEADER); bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = bm.bmWidth; bi.biWidth = bm.bmWidth;
bi.biHeight = bm.bmHeight; bi.biHeight = bm.bmHeight;
bi.biPlanes = 1; bi.biPlanes = 1;
bi.biBitCount = biBits; bi.biBitCount = biBits;
bi.biCompression = biStyle; bi.biCompression = biStyle;
bi.biSizeImage = 0; bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0; bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0; bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0; bi.biClrUsed = 0;
bi.biClrImportant = 0; bi.biClrImportant = 0;
dwLen = bi.biSize + wxPaletteSize(&bi); dwLen = bi.biSize + wxPaletteSize(&bi);
hdc = GetDC((HWND) NULL); hdc = GetDC((HWND) NULL);
hpal = SelectPalette(hdc, hpal, FALSE); hpal = SelectPalette(hdc, hpal, FALSE);
RealizePalette(hdc); RealizePalette(hdc);
hdib = GlobalAlloc(GHND, dwLen); hdib = GlobalAlloc(GHND, dwLen);
if (!hdib) { if (!hdib) {
SelectPalette(hdc, hpal, FALSE); SelectPalette(hdc, hpal, FALSE);
ReleaseDC(NULL, hdc); ReleaseDC(NULL, hdc);
return NULL; return NULL;
} }
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib)); lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
#else #else
lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib); lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
#endif #endif
*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, GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS); 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
lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib); lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
#endif #endif
if (GetDIBits(hdc, if (GetDIBits(hdc,
hbm, hbm,
0, 0,
(WORD) bi.biHeight, (WORD) bi.biHeight,
(LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi), (LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi),
(LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) { (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
GlobalUnlock(hdib); GlobalUnlock(hdib);
hdib = NULL; hdib = NULL;
SelectPalette(hdc, hpal, FALSE); SelectPalette(hdc, hpal, FALSE);
ReleaseDC((HWND) NULL, hdc); ReleaseDC((HWND) NULL, hdc);
return NULL; return NULL;
} }
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 ***************/ /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
/**************************************************************************** /****************************************************************************
* * * *
* FUNCTION : lread(int fh, VOID FAR *pv, DWORD ul) * * FUNCTION : lread(int fh, VOID FAR *pv, DWORD ul) *
* * * *
* PURPOSE : Reads data in steps of 32k till all the data has been read.* * PURPOSE : Reads data in steps of 32k till all the data has been read.*
* * * *
* RETURNS : 0 - If read did not proceed correctly. * * RETURNS : 0 - If read did not proceed correctly. *
* number of bytes read otherwise. * * number of bytes read otherwise. *
* * * *
****************************************************************************/ ****************************************************************************/
static DWORD PASCAL lread(int fh, void far *pv, DWORD ul) static DWORD PASCAL lread(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__)
BYTE *hp = (BYTE *) pv; BYTE *hp = (BYTE *) pv;
#else #else
BYTE huge *hp = (BYTE huge *) pv; BYTE huge *hp = (BYTE huge *) pv;
#endif #endif
while (ul > (DWORD) MAXREAD) { while (ul > (DWORD) MAXREAD) {
if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD) if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
return 0; return 0;
ul -= MAXREAD; ul -= MAXREAD;
hp += MAXREAD; hp += MAXREAD;
} }
if (_lread(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul) if (_lread(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
return 0; return 0;
return ulT; return ulT;
} }
/**************************************************************************** /****************************************************************************
* * * *
* FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) * * FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) *
* * * *
* PURPOSE : Writes data in steps of 32k till all the data is written. * * PURPOSE : Writes data in steps of 32k till all the data is written. *
* * * *
* RETURNS : 0 - If write did not proceed correctly. * * RETURNS : 0 - If write did not proceed correctly. *
* number of bytes written otherwise. * * number of bytes written otherwise. *
* * * *
****************************************************************************/ ****************************************************************************/
static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul) 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__)
BYTE *hp = (BYTE *) pv; BYTE *hp = (BYTE *) pv;
#else #else
BYTE huge *hp = (BYTE huge *) pv; BYTE huge *hp = (BYTE huge *) pv;
#endif #endif
while (ul > MAXREAD) { while (ul > MAXREAD) {
if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD) if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
return 0; return 0;
ul -= MAXREAD; ul -= MAXREAD;
hp += MAXREAD; hp += MAXREAD;
} }
if (_lwrite(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul) if (_lwrite(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
return 0; return 0;
return ulT; return ulT;
} }
/**************************************************************************** /****************************************************************************
@@ -408,25 +408,24 @@ static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
* FUNCTION : ReadDIB(hWnd) * FUNCTION : ReadDIB(hWnd)
* *
* PURPOSE : Reads a DIB from a file, obtains a handle to its * PURPOSE : Reads a DIB from a file, obtains a handle to its
* BITMAPINFO struct. and loads the DIB. Once the DIB * BITMAPINFO struct. and loads the DIB. Once the DIB
* is loaded, the function also creates a bitmap and * is loaded, the function also creates a bitmap and
* palette out of the DIB for a device-dependent form. * palette out of the DIB for a device-dependent form.
* *
* RETURNS : TRUE - DIB loaded and bitmap/palette created * RETURNS : TRUE - DIB loaded and bitmap/palette created
* The DIBINIT structure pointed to by pInfo is * The DIBINIT structure pointed to by pInfo is
* filled with the appropriate handles. * filled with the appropriate handles.
* FALSE - otherwise * FALSE - otherwise
* *
****************************************************************************/ ****************************************************************************/
BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette) BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
{ {
int fh; int fh;
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
OFSTRUCT of; OFSTRUCT of;
BITMAPFILEHEADER bf; BITMAPFILEHEADER bf;
WORD nNumColors; WORD nNumColors;
BOOL result = FALSE; BOOL result = FALSE;
wxChar str[128];
WORD offBits; WORD offBits;
HDC hDC; HDC hDC;
BOOL bCoreHead = FALSE; BOOL bCoreHead = FALSE;
@@ -436,15 +435,14 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
fh = OpenFile (wxFNCONV(lpFileName), &of, OF_READ); fh = OpenFile (wxFNCONV(lpFileName), &of, OF_READ);
if (fh == -1) { if (fh == -1) {
wsprintf(str,wxT("Can't open file '%s'"), lpFileName); wxLogError(_("Can't open file '%s'"), lpFileName);
MessageBox(NULL, str, wxT("Error"), MB_ICONSTOP | MB_OK); return (0);
return (0);
} }
hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) + hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
256 * sizeof(RGBQUAD))); 256 * sizeof(RGBQUAD)));
if (!hDIB) if (!hDIB)
return(0); return(0);
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB)); lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
@@ -454,56 +452,56 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
/* read the BITMAPFILEHEADER */ /* read the BITMAPFILEHEADER */
if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf))) if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
goto ErrExit; goto ErrExit;
if (bf.bfType != 0x4d42) /* 'BM' */ if (bf.bfType != 0x4d42) /* 'BM' */
goto ErrExit; goto ErrExit;
if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER))) if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
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;
lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight; lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth; lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
bCoreHead = TRUE; bCoreHead = TRUE;
} }
else else
{ {
// get to the start of the header and read INFOHEADER // get to the start of the header and read INFOHEADER
_llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET); _llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);
if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER))) if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
goto ErrExit; 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 + hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
nNumColors * sizeof(RGBQUAD) + nNumColors * sizeof(RGBQUAD) +
lpbi->biSizeImage, 0); lpbi->biSizeImage, 0);
if (!hDIB) /* can't resize buffer for loading */ if (!hDIB) /* can't resize buffer for loading */
goto ErrExit2; goto ErrExit2;
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB)); lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
@@ -513,24 +511,24 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
/* read the color table */ /* read the color table */
if (!bCoreHead) if (!bCoreHead)
_lread(fh, (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;
_lread(fh, (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;
pQuad[i].rgbReserved = 0; pQuad[i].rgbReserved = 0;
} }
} }
/* offset to the bits from start of DIB header */ /* offset to the bits from start of DIB header */
@@ -543,28 +541,28 @@ BOOL wxReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage)) if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
{ {
GlobalUnlock(hDIB); GlobalUnlock(hDIB);
hDC = GetDC(NULL); hDC = GetDC(NULL);
if (!MakeBitmapAndPalette(hDC, hDIB, palette, if (!MakeBitmapAndPalette(hDC, hDIB, palette,
bitmap)) bitmap))
{ {
ReleaseDC(NULL,hDC); ReleaseDC(NULL,hDC);
goto ErrExit2; goto ErrExit2;
} }
else else
{ {
ReleaseDC(NULL,hDC); ReleaseDC(NULL,hDC);
GlobalFree(hDIB); GlobalFree(hDIB);
result = TRUE; result = TRUE;
} }
} }
else else
{ {
ErrExit: ErrExit:
GlobalUnlock(hDIB); GlobalUnlock(hDIB);
ErrExit2: ErrExit2:
GlobalFree(hDIB); GlobalFree(hDIB);
} }
_lclose(fh); _lclose(fh);
@@ -587,7 +585,7 @@ ErrExit2:
* *
****************************************************************************/ ****************************************************************************/
static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB, static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
HPALETTE * phPal, HBITMAP * phBitmap) HPALETTE * phPal, HBITMAP * phBitmap)
{ {
LPBITMAPINFOHEADER lpInfo; LPBITMAPINFOHEADER lpInfo;
BOOL result = FALSE; BOOL result = FALSE;
@@ -604,41 +602,41 @@ static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
hPalette = wxMakeDIBPalette(lpInfo); hPalette = wxMakeDIBPalette(lpInfo);
if ( hPalette ) if ( hPalette )
{ {
// Need to realize palette for converting DIB to bitmap. // Need to realize palette for converting DIB to bitmap.
hOldPal = SelectPalette(hDC, hPalette, TRUE); hOldPal = SelectPalette(hDC, hPalette, TRUE);
RealizePalette(hDC); RealizePalette(hDC);
lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize + lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
(WORD)lpInfo->biClrUsed * sizeof(RGBQUAD); (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits, hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
(LPBITMAPINFO)lpInfo, DIB_RGB_COLORS); (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
SelectPalette(hDC, hOldPal, TRUE); SelectPalette(hDC, hOldPal, TRUE);
RealizePalette(hDC); RealizePalette(hDC);
if (!hBitmap) if (!hBitmap)
DeleteObject(hPalette); DeleteObject(hPalette);
else else
{ {
*phBitmap = hBitmap; *phBitmap = hBitmap;
*phPal = hPalette; *phPal = hPalette;
result = TRUE; result = TRUE;
} }
} }
return(result); return(result);
} }
/**************************************************************************** /****************************************************************************
* * * *
* FUNCTION : wxMakeDIBPalette(lpInfo) * * FUNCTION : wxMakeDIBPalette(lpInfo) *
* * * *
* PURPOSE : Given a BITMAPINFOHEADER, create a palette based on * PURPOSE : Given a BITMAPINFOHEADER, create a palette based on
* the color table. * the color table.
* *
* * * *
* RETURNS : non-zero - handle of a corresponding palette * RETURNS : non-zero - handle of a corresponding palette
* zero - unable to create palette * zero - unable to create palette
* * * *
****************************************************************************/ ****************************************************************************/
HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo) HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
{ {
@@ -656,34 +654,34 @@ HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
if (lpInfo->biClrUsed) if (lpInfo->biClrUsed)
{ {
/* /*
npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) + npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
(WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY)); (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
*/ */
npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) + npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
(WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY)); (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
if (!npPal) if (!npPal)
return(FALSE); return(FALSE);
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; i < lpInfo->biClrUsed; i++, lpRGB++) for (i = 0; i < lpInfo->biClrUsed; i++, lpRGB++)
{ {
npPal->palPalEntry[i].peRed = lpRGB->rgbRed; npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen; npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue; npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
npPal->palPalEntry[i].peFlags = 0; npPal->palPalEntry[i].peFlags = 0;
} }
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
@@ -691,7 +689,7 @@ HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
** some good color choices. ** some good color choices.
*/ */
else else
return((HPALETTE) GetStockObject(DEFAULT_PALETTE)); return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
#endif #endif
} }