/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.cpp
// Purpose: wxBitmap
-// Author: AUTHOR
+// Author: David Webster
// Modified by:
-// Created: ??/??/98
+// Created: 08/08/99
// RCS-ID: $Id$
-// Copyright: (c) AUTHOR
+// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
-#pragma implementation "bitmap.h"
+ #pragma implementation "bitmap.h"
#endif
-#include "wx/setup.h"
-#include "wx/utils.h"
-#include "wx/palette.h"
-#include "wx/bitmap.h"
-#include "wx/icon.h"
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+ #include <stdio.h>
+
+ #include "wx/list.h"
+ #include "wx/utils.h"
+ #include "wx/app.h"
+ #include "wx/palette.h"
+ #include "wx/dcmemory.h"
+ #include "wx/bitmap.h"
+ #include "wx/icon.h"
+#endif
+
+#include "wx/os2/private.h"
#include "wx/log.h"
-#if !USE_SHARED_LIBRARIES
+//#include "wx/msw/dib.h"
+#include "wx/image.h"
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
+
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
-#endif
+
+IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxBitmapRefData
+// ----------------------------------------------------------------------------
wxBitmapRefData::wxBitmapRefData()
{
- m_ok = FALSE;
- m_width = 0;
- m_height = 0;
- m_depth = 0;
- m_quality = 0;
- m_numColors = 0;
- m_bitmapMask = NULL;
-}
-
-wxBitmapRefData::~wxBitmapRefData()
+ m_nQuality = 0;
+ m_pSelectedInto = NULL;
+ m_nNumColors = 0;
+ m_pBitmapMask = NULL;
+ m_hBitmap = (WXHBITMAP) NULL;
+} // end of wxBitmapRefData::wxBitmapRefData
+
+void wxBitmapRefData::Free()
{
- /*
- * TODO: delete the bitmap data here.
- */
+ wxASSERT_MSG( !m_pSelectedInto,
+ wxT("deleting bitmap still selected into wxMemoryDC") );
- if (m_bitmapMask)
- delete m_bitmapMask;
- m_bitmapMask = NULL;
-}
+ if (m_hBitmap)
+ {
+ if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
+ {
+ wxLogLastError("GpiDeleteBitmap(hbitmap)");
+ }
+ }
-wxList wxBitmap::sm_handlers;
+ delete m_pBitmapMask;
+ m_pBitmapMask = NULL;
+} // end of wxBitmapRefData::Free
-wxBitmap::wxBitmap()
+// ----------------------------------------------------------------------------
+// wxBitmap creation
+// ----------------------------------------------------------------------------
+
+// this function should be called from all wxBitmap ctors
+void wxBitmap::Init()
{
- m_refData = NULL;
+ // m_refData = NULL; done in the base class ctor
- if ( wxTheBitmapList )
+ if (wxTheBitmapList)
wxTheBitmapList->AddBitmap(this);
-}
+} // end of wxBitmap::Init
-wxBitmap::~wxBitmap()
+bool wxBitmap::CopyFromIconOrCursor(
+ const wxGDIImage& rIcon
+)
{
- if (wxTheBitmapList)
- wxTheBitmapList->DeleteObject(this);
-}
+ HPOINTER hIcon = (HPOINTER)rIcon.GetHandle();
+ POINTERINFO SIconInfo;
-wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
-{
- m_refData = new wxBitmapRefData;
+ if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
+ {
+ wxLogLastError(wxT("WinQueryPointerInfo"));
+ return FALSE;
+ }
+ wxBitmapRefData* pRefData = new wxBitmapRefData;
- M_BITMAPDATA->m_width = the_width ;
- M_BITMAPDATA->m_height = the_height ;
- M_BITMAPDATA->m_depth = no_bits ;
- M_BITMAPDATA->m_numColors = 0;
+ m_refData = pRefData;
- /* TODO: create the bitmap from data */
+ int nWidth = rIcon.GetWidth();
+ int nHeight = rIcon.GetHeight();
- if ( wxTheBitmapList )
- wxTheBitmapList->AddBitmap(this);
-}
+ pRefData->m_nWidth = nWidth;
+ pRefData->m_nHeight = nHeight;
+ pRefData->m_nDepth = wxDisplayDepth();
-wxBitmap::wxBitmap(int w, int h, int d)
-{
- (void)Create(w, h, d);
+ pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
- if ( wxTheBitmapList )
- wxTheBitmapList->AddBitmap(this);
-}
+ //
+ // No mask in the Info struct in OS/2
+ //
+ return(TRUE);
+} // end of wxBitmap::CopyFromIconOrCursor
-wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
+bool wxBitmap::CopyFromCursor(
+ const wxCursor& rCursor
+)
{
- (void) Create(data, type, width, height, depth);
+ UnRef();
- if ( wxTheBitmapList )
- wxTheBitmapList->AddBitmap(this);
-}
+ if (!rCursor.Ok())
+ return(FALSE);
+ return(CopyFromIconOrCursor(rCursor));
+} // end of wxBitmap::CopyFromCursor
-wxBitmap::wxBitmap(const wxString& filename, long type)
+bool wxBitmap::CopyFromIcon(
+ const wxIcon& rIcon
+)
{
- LoadFile(filename, (int)type);
+ UnRef();
- if ( wxTheBitmapList )
- wxTheBitmapList->AddBitmap(this);
-}
+ if (!rIcon.Ok())
+ return(FALSE);
+
+ return CopyFromIconOrCursor(rIcon);
+} // end of wxBitmap::CopyFromIcon
-/* TODO: maybe allow creation from XPM
-// Create from data
-wxBitmap::wxBitmap(const char **data)
+wxBitmap::~wxBitmap()
{
- (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
-}
-*/
+ if (wxTheBitmapList)
+ wxTheBitmapList->DeleteObject(this);
+} // end of wxBitmap::~wxBitmap
+
+wxBitmap::wxBitmap(
+ const char zBits[]
+, int nTheWidth
+, int nTheHeight
+, int nNoBits
+)
+{
+ Init();
+
+ wxBitmapRefData* pRefData = new wxBitmapRefData;
+ BITMAPINFOHEADER2 vHeader;
+ BITMAPINFO2 vInfo;
+ HDC hDc;
+ HPS hPs;
+ DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+ SIZEL vSize = {0, 0};
+
+ wxASSERT(vHabmain != NULL);
+
+ hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+
+ vHeader.cbFix = sizeof(vHeader);
+ vHeader.cx = (USHORT)nTheWidth;
+ vHeader.cy = (USHORT)nTheHeight;
+ vHeader.cPlanes = 1L;
+ vHeader.cBitCount = nNoBits;
+ vHeader.ulCompression = BCA_UNCOMP;
+ vHeader.cxResolution = 0;
+ vHeader.cyResolution = 0;
+ vHeader.cclrUsed = 0;
+ vHeader.cclrImportant = 0;
+ vHeader.usUnits = BRU_METRIC;
+ vHeader.usRecording = BRA_BOTTOMUP;
+ vHeader.usRendering = BRH_NOTHALFTONED;
+ vHeader.cSize1 = 0;
+ vHeader.cSize2 = 0;
+ vHeader.ulColorEncoding = 0;
+ vHeader.ulIdentifier = 0;
+
+ hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
+ if (hPs == 0)
+ {
+ wxLogLastError("GpiCreatePS Failure");
+ }
+
+ m_refData = pRefData;
+
+ pRefData->m_nWidth = nTheWidth;
+ pRefData->m_nHeight = nTheHeight;
+ pRefData->m_nDepth = nNoBits;
+ pRefData->m_nNumColors = 0;
+ pRefData->m_pSelectedInto = NULL;
-bool wxBitmap::Create(int w, int h, int d)
+ HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
+ if (!hBmp)
+ {
+ wxLogLastError("CreateBitmap");
+ }
+ SetHBITMAP((WXHBITMAP)hBmp);
+} // end of wxBitmap::wxBitmap
+
+//
+// Create from XPM data
+//
+wxBitmap::wxBitmap(
+ char** ppData
+)
{
- UnRef();
+ Init();
+
+ (void)Create( (void *)ppData
+ ,wxBITMAP_TYPE_XPM_DATA
+ ,0
+ ,0
+ ,0
+ );
+} // end of wxBitmap::wxBitmap
+
+wxBitmap::wxBitmap(
+ const char** ppData
+)
+{
+ Init();
+
+ (void)Create( (void *)ppData
+ ,wxBITMAP_TYPE_XPM_DATA
+ ,0
+ ,0
+ ,0
+ );
+} // end of wxBitmap::wxBitmap
+
+wxBitmap::wxBitmap(
+ int nW
+, int nH
+, int nD
+)
+{
+ Init();
+
+ (void)Create( nW
+ ,nH
+ ,nD
+ );
+} // end of wxBitmap::wxBitmap
+
+wxBitmap::wxBitmap(
+ void* pData
+, long lType
+, int nWidth
+, int nHeight
+, int nDepth
+)
+{
+ Init();
+
+ (void)Create( pData
+ ,lType
+ ,nWidth
+ ,nHeight
+ ,nDepth
+ );
+} // end of wxBitmap::wxBitmap
+
+wxBitmap::wxBitmap(
+ const wxString& rFilename
+, long lType
+)
+{
+ Init();
+
+ LoadFile( rFilename
+ ,(int)lType
+ );
+} // end of wxBitmap::wxBitmap
+
+bool wxBitmap::Create(
+ int nW
+, int nH
+, int nD
+)
+{
+ HBITMAP hBmp;
+ BITMAPINFOHEADER2 vHeader;
+ wxASSERT(vHabmain != NULL);
+ UnRef();
m_refData = new wxBitmapRefData;
+ GetBitmapData()->m_nWidth = nW;
+ GetBitmapData()->m_nHeight = nH;
+ GetBitmapData()->m_nDepth = nD;
- M_BITMAPDATA->m_width = w;
- M_BITMAPDATA->m_height = h;
- M_BITMAPDATA->m_depth = d;
+ if (nD > 0)
+ {
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ SIZEL vSize = {0, 0};
+ HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
+
+ memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
+ vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ vHeader.cx = nW;
+ vHeader.cy = nH;
+ vHeader.cPlanes = 1;
+ vHeader.cBitCount = nD;
+
+ hBmp = ::GpiCreateBitmap( hPS
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+ ::GpiDestroyPS(hPS);
+ ::DevCloseDC(hDC);
+ }
+ else
+ {
+ HPS hPSScreen;
+ HDC hDCScreen;
+ LONG lBitCount;
+
+ hPSScreen = ::WinGetScreenPS(HWND_DESKTOP);
+ hDCScreen = ::GpiQueryDevice(hPSScreen);
+ ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
+
+ memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
+ vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ vHeader.cx = nW;
+ vHeader.cy = nH;
+ vHeader.cPlanes = 1;
+ vHeader.cBitCount = lBitCount;
+
+ hBmp = ::GpiCreateBitmap( hPSScreen
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ GetBitmapData()->m_nDepth = wxDisplayDepth();
+ ::WinReleasePS(hPSScreen);
+ }
+ SetHBITMAP((WXHBITMAP)hBmp);
- /* TODO: create new bitmap */
+#if WXWIN_COMPATIBILITY_2
+ GetBitmapData()->m_bOk = hBmp != 0;
+#endif // WXWIN_COMPATIBILITY_2
- return M_BITMAPDATA->m_ok;
-}
+ return Ok();
+} // end of wxBitmap::Create
-bool wxBitmap::LoadFile(const wxString& filename, long type)
+bool wxBitmap::LoadFile(
+ const wxString& rFilename
+, long lType
+)
{
- UnRef();
+ HPS hPs = NULLHANDLE;
- m_refData = new wxBitmapRefData;
+ UnRef();
- wxBitmapHandler *handler = FindHandler(type);
+ wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
+ ,wxBitmapHandler
+ );
- if ( handler == NULL ) {
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ if (pHandler)
+ {
+ m_refData = new wxBitmapRefData;
- return FALSE;
+ return(pHandler->LoadFile( this
+ ,rFilename
+ ,hPs
+ ,lType
+ , -1
+ , -1
+ ));
}
+ else
+ {
+ wxImage vImage;
- return handler->LoadFile(this, filename, type, -1, -1);
-}
+ if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
+ return(FALSE);
-bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
+ *this = vImage.ConvertToBitmap();
+
+ return(TRUE);
+ }
+} // end of wxBitmap::LoadFile
+
+bool wxBitmap::Create(
+ void* pData
+, long lType
+, int nWidth
+, int nHeight
+, int nDepth
+)
{
UnRef();
- m_refData = new wxBitmapRefData;
-
- wxBitmapHandler *handler = FindHandler(type);
+ wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
+ ,wxBitmapHandler
+ );
- if ( handler == NULL ) {
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ if (!pHandler)
+ {
+ wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
+ "type %d defined."), lType);
- return FALSE;
+ return(FALSE);
}
- return handler->Create(this, data, type, width, height, depth);
-}
+ m_refData = new wxBitmapRefData;
-bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
+ return(pHandler->Create( this
+ ,pData
+ ,lType
+ ,nWidth
+ ,nHeight
+ ,nDepth
+ ));
+} // end of wxBitmap::Create
+
+bool wxBitmap::SaveFile(
+ const wxString& rFilename
+, int lType
+, const wxPalette* pPalette
+)
{
- wxBitmapHandler *handler = FindHandler(type);
+ wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
+ ,wxBitmapHandler
+ );
- if ( handler == NULL ) {
- wxLogWarning("no bitmap handler for type %d defined.", type);
+ if (pHandler)
+ {
+ return pHandler->SaveFile( this
+ ,rFilename
+ ,lType
+ ,pPalette
+ );
+ }
+ else
+ {
+ // FIXME what about palette? shouldn't we use it?
+ wxImage vImage(*this);
- return FALSE;
- }
+ if (!vImage.Ok())
+ return(FALSE);
- return handler->SaveFile(this, filename, type, palette);
-}
+ return(vImage.SaveFile( rFilename
+ ,lType
+ ));
+ }
+} // end of wxBitmap::SaveFile
-void wxBitmap::SetWidth(int w)
-{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
- M_BITMAPDATA->m_width = w;
-}
+// ----------------------------------------------------------------------------
+// wxImage-wxBitmap convertion
+// ----------------------------------------------------------------------------
-void wxBitmap::SetHeight(int h)
+bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
- M_BITMAPDATA->m_height = h;
-}
+// TODO:
+/*
+ int sizeLimit = 1024*768*3;
+
+ // width and height of the device-dependent bitmap
+ int width = GetWidth();
+ int bmpHeight = GetHeight();
+
+ // calc the number of bytes per scanline and padding
+ int bytePerLine = width*3;
+ int sizeDWORD = sizeof( DWORD );
+ int lineBoundary = bytePerLine % sizeDWORD;
+ int padding = 0;
+ if( lineBoundary > 0 )
+ {
+ padding = sizeDWORD - lineBoundary;
+ bytePerLine += padding;
+ }
+ // calc the number of DIBs and heights of DIBs
+ int numDIB = 1;
+ int hRemain = 0;
+ int height = sizeLimit/bytePerLine;
+ if( height >= bmpHeight )
+ height = bmpHeight;
+ else
+ {
+ numDIB = bmpHeight / height;
+ hRemain = bmpHeight % height;
+ if( hRemain >0 ) numDIB++;
+ }
-void wxBitmap::SetDepth(int d)
-{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ // set bitmap parameters
+ wxBitmap bitmap;
+ wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
+ bitmap.SetWidth( width );
+ bitmap.SetHeight( bmpHeight );
+ bitmap.SetDepth( wxDisplayDepth() );
+
+ // create a DIB header
+ int headersize = sizeof(BITMAPINFOHEADER);
+ LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
+ wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
+ // Fill in the DIB header
+ lpDIBh->bmiHeader.biSize = headersize;
+ lpDIBh->bmiHeader.biWidth = (DWORD)width;
+ lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+ lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ // the general formula for biSizeImage:
+ // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
+ lpDIBh->bmiHeader.biPlanes = 1;
+ lpDIBh->bmiHeader.biBitCount = 24;
+ lpDIBh->bmiHeader.biCompression = BI_RGB;
+ lpDIBh->bmiHeader.biClrUsed = 0;
+ // These seem not really needed for our purpose here.
+ lpDIBh->bmiHeader.biClrImportant = 0;
+ lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+ lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+ // memory for DIB data
+ unsigned char *lpBits;
+ lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
+ if( !lpBits )
+ {
+ wxFAIL_MSG( wxT("could not allocate memory for DIB") );
+ free( lpDIBh );
+ return bitmap;
+ }
- M_BITMAPDATA->m_depth = d;
-}
+ // create and set the device-dependent bitmap
+ HDC hdc = ::GetDC(NULL);
+ HDC memdc = ::CreateCompatibleDC( hdc );
+ HBITMAP hbitmap;
+ hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
+ ::SelectObject( memdc, hbitmap);
+
+ // copy image data into DIB data and then into DDB (in a loop)
+ unsigned char *data = GetData();
+ int i, j, n;
+ int origin = 0;
+ unsigned char *ptdata = data;
+ unsigned char *ptbits;
+
+ for( n=0; n<numDIB; n++ )
+ {
+ if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
+ {
+ // redefine height and size of the (possibly) last smaller DIB
+ // memory is not reallocated
+ height = hRemain;
+ lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+ lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ }
+ ptbits = lpBits;
+
+ for( j=0; j<height; j++ )
+ {
+ for( i=0; i<width; i++ )
+ {
+ *(ptbits++) = *(ptdata+2);
+ *(ptbits++) = *(ptdata+1);
+ *(ptbits++) = *(ptdata );
+ ptdata += 3;
+ }
+ for( i=0; i< padding; i++ ) *(ptbits++) = 0;
+ }
+ ::StretchDIBits( memdc, 0, origin, width, height,\
+ 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+ origin += height;
+ // if numDIB = 1, lines below can also be used
+ // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
+ // The above line is equivalent to the following two lines.
+ // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
+ // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
+ // or the following lines
+ // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
+ // HDC memdc = ::CreateCompatibleDC( hdc );
+ // ::SelectObject( memdc, hbitmap);
+ // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
+ // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
+ // ::SelectObject( memdc, 0 );
+ // ::DeleteDC( memdc );
+ }
+ bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
-void wxBitmap::SetQuality(int q)
-{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ // similarly, created an mono-bitmap for the possible mask
+ if( HasMask() )
+ {
+ hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
+ ::SelectObject( memdc, hbitmap);
+ if( numDIB == 1 ) height = bmpHeight;
+ else height = sizeLimit/bytePerLine;
+ lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+ lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ origin = 0;
+ unsigned char r = GetMaskRed();
+ unsigned char g = GetMaskGreen();
+ unsigned char b = GetMaskBlue();
+ unsigned char zero = 0, one = 255;
+ ptdata = data;
+ for( n=0; n<numDIB; n++ )
+ {
+ if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
+ {
+ // redefine height and size of the (possibly) last smaller DIB
+ // memory is not reallocated
+ height = hRemain;
+ lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+ lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+ }
+ ptbits = lpBits;
+ for( int j=0; j<height; j++ )
+ {
+ for(i=0; i<width; i++ )
+ {
+ if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
+ {
+ *(ptbits++) = one;
+ *(ptbits++) = one;
+ *(ptbits++) = one;
+ }
+ else
+ {
+ *(ptbits++) = zero;
+ *(ptbits++) = zero;
+ *(ptbits++) = zero;
+ }
+ }
+ for( i=0; i< padding; i++ ) *(ptbits++) = zero;
+ }
+ ::StretchDIBits( memdc, 0, origin, width, height,\
+ 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+ origin += height;
+ }
+ // create a wxMask object
+ wxMask *mask = new wxMask();
+ mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
+ bitmap.SetMask( mask );
+ }
- M_BITMAPDATA->m_quality = q;
-}
+ // free allocated resources
+ ::SelectObject( memdc, 0 );
+ ::DeleteDC( memdc );
+ ::ReleaseDC(NULL, hdc);
+ free(lpDIBh);
+ free(lpBits);
-void wxBitmap::SetOk(bool isOk)
-{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ // check the wxBitmap object
+ if( bitmap.GetHBITMAP() )
+ bitmap.SetOk( TRUE );
+ else
+ bitmap.SetOk( FALSE );
+*/
- M_BITMAPDATA->m_ok = isOk;
+ return TRUE;
}
-void wxBitmap::SetPalette(const wxPalette& palette)
+wxImage wxBitmap::ConvertToImage() const
{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ wxImage image;
+
+ wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+
+ // create an wxImage object
+ int width = GetWidth();
+ int height = GetHeight();
+ image.Create( width, height );
+ unsigned char *data = image.GetData();
+ if( !data )
+ {
+ wxFAIL_MSG( wxT("could not allocate data for image") );
+ return wxNullImage;
+ }
- M_BITMAPDATA->m_bitmapPalette = palette ;
-}
+ // calc the number of bytes per scanline and padding in the DIB
+ int bytePerLine = width*3;
+ int sizeDWORD = sizeof( DWORD );
+ int lineBoundary = bytePerLine % sizeDWORD;
+ int padding = 0;
+ if( lineBoundary > 0 )
+ {
+ padding = sizeDWORD - lineBoundary;
+ bytePerLine += padding;
+ }
+// TODO:
+/*
+ // create a DIB header
+ int headersize = sizeof(BITMAPINFOHEADER);
+ LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
+ if( !lpDIBh )
+ {
+ wxFAIL_MSG( wxT("could not allocate data for DIB header") );
+ free( data );
+ return;
+ }
+ // Fill in the DIB header
+ lpDIBh->bmiHeader.biSize = headersize;
+ lpDIBh->bmiHeader.biWidth = width;
+ lpDIBh->bmiHeader.biHeight = -height;
+ lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
+ lpDIBh->bmiHeader.biPlanes = 1;
+ lpDIBh->bmiHeader.biBitCount = 24;
+ lpDIBh->bmiHeader.biCompression = BI_RGB;
+ lpDIBh->bmiHeader.biClrUsed = 0;
+ // These seem not really needed for our purpose here.
+ lpDIBh->bmiHeader.biClrImportant = 0;
+ lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+ lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+ // memory for DIB data
+ unsigned char *lpBits;
+ lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
+ if( !lpBits )
+ {
+ wxFAIL_MSG( wxT("could not allocate data for DIB") );
+ free( data );
+ free( lpDIBh );
+ return;
+ }
-void wxBitmap::SetMask(wxMask *mask)
-{
- if (!M_BITMAPDATA)
- m_refData = new wxBitmapRefData;
+ // copy data from the device-dependent bitmap to the DIB
+ HDC hdc = ::GetDC(NULL);
+ HBITMAP hbitmap;
+ hbitmap = (HBITMAP) bitmap.GetHBITMAP();
+ ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
+
+ // copy DIB data into the wxImage object
+ int i, j;
+ unsigned char *ptdata = data;
+ unsigned char *ptbits = lpBits;
+ for( i=0; i<height; i++ )
+ {
+ for( j=0; j<width; j++ )
+ {
+ *(ptdata++) = *(ptbits+2);
+ *(ptdata++) = *(ptbits+1);
+ *(ptdata++) = *(ptbits );
+ ptbits += 3;
+ }
+ ptbits += padding;
+ }
- M_BITMAPDATA->m_bitmapMask = mask ;
-}
+ // similarly, set data according to the possible mask bitmap
+ if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
+ {
+ hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
+ // memory DC created, color set, data copied, and memory DC deleted
+ HDC memdc = ::CreateCompatibleDC( hdc );
+ ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
+ ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
+ ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
+ ::DeleteDC( memdc );
+ // background color set to RGB(16,16,16) in consistent with wxGTK
+ unsigned char r=16, g=16, b=16;
+ ptdata = data;
+ ptbits = lpBits;
+ for( i=0; i<height; i++ )
+ {
+ for( j=0; j<width; j++ )
+ {
+ if( *ptbits != 0 )
+ ptdata += 3;
+ else
+ {
+ *(ptdata++) = r;
+ *(ptdata++) = g;
+ *(ptdata++) = b;
+ }
+ ptbits += 3;
+ }
+ ptbits += padding;
+ }
+ SetMaskColour( r, g, b );
+ SetMask( TRUE );
+ }
+ else
+ {
+ SetMask( FALSE );
+ }
+ // free allocated resources
+ ::ReleaseDC(NULL, hdc);
+ free(lpDIBh);
+ free(lpBits);
+*/
-void wxBitmap::AddHandler(wxBitmapHandler *handler)
-{
- sm_handlers.Append(handler);
+ return image;
}
-void wxBitmap::InsertHandler(wxBitmapHandler *handler)
-{
- sm_handlers.Insert(handler);
-}
-bool wxBitmap::RemoveHandler(const wxString& name)
+// ----------------------------------------------------------------------------
+// sub bitmap extraction
+// ----------------------------------------------------------------------------
+
+wxBitmap wxBitmap::GetSubBitmap(
+ const wxRect& rRect
+) const
{
- wxBitmapHandler *handler = FindHandler(name);
- if ( handler )
+ wxCHECK_MSG( Ok() &&
+ (rRect.x >= 0) && (rRect.y >= 0) &&
+ (rRect.x + rRect.width <= GetWidth()) &&
+ (rRect.y + rRect.height <= GetHeight()),
+ wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
+
+ wxBitmap vRet( rRect.width
+ ,rRect.height
+ ,GetDepth()
+ );
+ wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
+
+
+ //
+ // Copy bitmap data
+ //
+ SIZEL vSize = {0, 0};
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
+ HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
+ POINTL vPoint[4] = { rRect.x, rRect.y,
+ rRect.x + rRect.width, rRect.y + rRect.height,
+ 0, 0, GetWidth(), GetHeight()
+ };
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
+ ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
+ ::GpiBitBlt( hPSDst
+ ,hPSSrc
+ ,4L
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+
+ //
+ // Copy mask if there is one
+ //
+ if (GetMask())
{
- sm_handlers.DeleteObject(handler);
- return TRUE;
+ BITMAPINFOHEADER2 vBmih;
+
+ memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+ vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
+ vBmih.cx = rRect.width;
+ vBmih.cy = rRect.height;
+ vBmih.cPlanes = 1;
+ vBmih.cBitCount = 1;
+
+ HBITMAP hBmpMask = ::GpiCreateBitmap( hPSDst
+ ,&vBmih
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
+ ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
+ ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
+ ::GpiBitBlt( hPSDst
+ ,hPSSrc
+ ,4L
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+
+ wxMask* pMask = new wxMask((WXHBITMAP)hBmpMask);
+ vRet.SetMask(pMask);
}
- else
- return FALSE;
-}
-wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
+ ::GpiSetBitmap(hPSSrc, NULL);
+ ::GpiSetBitmap(hPSDst, NULL);
+ ::GpiDestroyPS(hPSSrc);
+ ::GpiDestroyPS(hPSDst);
+ ::DevCloseDC(hDCSrc);
+ ::DevCloseDC(hDCDst);
+ return vRet;
+} // end of wxBitmap::GetSubBitmap
+
+// ----------------------------------------------------------------------------
+// wxBitmap accessors
+// ----------------------------------------------------------------------------
+
+void wxBitmap::SetQuality(
+ int nQ
+)
{
- wxNode *node = sm_handlers.First();
- while ( node )
- {
- wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
- if ( handler->GetName() == name )
- return handler;
- node = node->Next();
- }
- return NULL;
-}
+ EnsureHasData();
-wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
+ GetBitmapData()->m_nQuality = nQ;
+} // end of wxBitmap::SetQuality
+
+#if WXWIN_COMPATIBILITY_2
+void wxBitmap::SetOk(
+ bool bOk
+)
{
- wxNode *node = sm_handlers.First();
- while ( node )
- {
- wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
- if ( handler->GetExtension() == extension &&
- (bitmapType == -1 || handler->GetType() == bitmapType) )
- return handler;
- node = node->Next();
- }
- return NULL;
-}
+ EnsureHasData();
+
+ GetBitmapData()->m_bOk = bOk;
+} // end of wxBitmap::SetOk
+#endif // WXWIN_COMPATIBILITY_2
-wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
+void wxBitmap::SetPalette(
+ const wxPalette& rPalette
+)
{
- wxNode *node = sm_handlers.First();
- while ( node )
- {
- wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
- if (handler->GetType() == bitmapType)
- return handler;
- node = node->Next();
- }
- return NULL;
-}
+ EnsureHasData();
-/*
- * wxMask
- */
+ GetBitmapData()->m_vBitmapPalette = rPalette;
+} // end of wxBitmap::SetPalette
+
+void wxBitmap::SetMask(
+ wxMask* pMask
+)
+{
+ EnsureHasData();
+
+ GetBitmapData()->m_pBitmapMask = pMask;
+} // end of wxBitmap::SetMask
+
+//
+// Will try something for OS/2 but not really sure how close
+// to the msw intent this is.
+//
+wxBitmap wxBitmap::GetBitmapForDC(
+ wxDC& rDc
+) const
+{
+ wxMemoryDC vMemDC;
+ wxBitmap vTmpBitmap( this->GetWidth()
+ ,this->GetHeight()
+ ,rDc.GetDepth()
+ );
+ WXHBITMAP vOldBitmap;
+ HPS hMemoryPS;
+ HPS hPs;
+ POINTL vPoint[4];
+ SIZEL vSize = {0,0};
+
+ hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ hPs = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+
+ // TODO: Set the points
+
+ vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
+ ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
+
+ return(vTmpBitmap);
+} // end of wxBitmap::GetBitmapForDC
+
+// ----------------------------------------------------------------------------
+// wxMask
+// ----------------------------------------------------------------------------
wxMask::wxMask()
{
-/* TODO
- m_maskBitmap = 0;
-*/
-}
+ m_hMaskBitmap = 0;
+} // end of wxMask::wxMask
// Construct a mask from a bitmap and a colour indicating
// the transparent area
-wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
+wxMask::wxMask(
+ const wxBitmap& rBitmap
+, const wxColour& rColour
+)
{
-/* TODO
- m_maskBitmap = 0;
-*/
- Create(bitmap, colour);
-}
+ m_hMaskBitmap = 0;
+ Create( rBitmap
+ ,rColour
+ );
+} // end of wxMask::wxMask
// Construct a mask from a bitmap and a palette index indicating
// the transparent area
-wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
+wxMask::wxMask(
+ const wxBitmap& rBitmap
+, int nPaletteIndex
+)
{
-/* TODO
- m_maskBitmap = 0;
-*/
-
- Create(bitmap, paletteIndex);
-}
+ m_hMaskBitmap = 0;
+ Create( rBitmap
+ ,nPaletteIndex
+ );
+} // end of wxMask::wxMask
// Construct a mask from a mono bitmap (copies the bitmap).
-wxMask::wxMask(const wxBitmap& bitmap)
+wxMask::wxMask(
+ const wxBitmap& rBitmap
+)
{
-/* TODO
- m_maskBitmap = 0;
-*/
-
- Create(bitmap);
-}
+ m_hMaskBitmap = 0;
+ Create(rBitmap);
+} // end of wxMask::wxMask
wxMask::~wxMask()
{
-// TODO: delete mask bitmap
-}
+ if (m_hMaskBitmap)
+ ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
+} // end of wxMask::~wxMask
// Create a mask from a mono bitmap (copies the bitmap).
-bool wxMask::Create(const wxBitmap& bitmap)
+bool wxMask::Create(
+ const wxBitmap& rBitmap
+)
{
-// TODO
- return FALSE;
-}
+ BITMAPINFOHEADER2 vBmih;
+ SIZEL vSize = {0, 0};
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
+ HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
+ POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
+ 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
+ };
+
+ if (m_hMaskBitmap)
+ {
+ ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+ m_hMaskBitmap = 0;
+ }
+ if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
+ {
+ return(FALSE);
+ }
+
+ memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+ vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
+ vBmih.cx = rBitmap.GetWidth();
+ vBmih.cy = rBitmap.GetHeight();
+ vBmih.cPlanes = 1;
+ vBmih.cBitCount = 1;
+
+ m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
+ ,&vBmih
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
+ ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
+ ::GpiBitBlt( hPSDst
+ ,hPSSrc
+ ,4L
+ ,vPoint
+ ,ROP_SRCCOPY
+ ,BBO_IGNORE
+ );
+
+ ::GpiDestroyPS(hPSSrc);
+ ::GpiDestroyPS(hPSDst);
+ ::DevCloseDC(hDCSrc);
+ ::DevCloseDC(hDCDst);
+ return(TRUE);
+} // end of wxMask::Create
// Create a mask from a bitmap and a palette index indicating
// the transparent area
-bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
+bool wxMask::Create(
+ const wxBitmap& rBitmap
+, int nPaletteIndex
+)
{
-// TODO
- return FALSE;
-}
+ if (m_hMaskBitmap)
+ {
+ ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+ m_hMaskBitmap = 0;
+ }
+ if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
+ {
+ unsigned char cRed;
+ unsigned char cGreen;
+ unsigned char cBlue;
+
+ if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
+ ,&cRed
+ ,&cGreen
+ ,&cBlue
+ ))
+ {
+ wxColour vTransparentColour( cRed
+ ,cGreen
+ ,cBlue
+ );
+
+ return (Create( rBitmap
+ ,vTransparentColour
+ ));
+ }
+ }
+ return(FALSE);
+} // end of wxMask::Create
// Create a mask from a bitmap and a colour indicating
// the transparent area
-bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
+bool wxMask::Create(
+ const wxBitmap& rBitmap
+, const wxColour& rColour
+)
{
-// TODO
- return FALSE;
-}
+ bool bOk = TRUE;
+ COLORREF vMaskColour = OS2RGB( rColour.Red()
+ ,rColour.Green()
+ ,rColour.Blue()
+ );
+ BITMAPINFOHEADER2 vBmih;
+ SIZEL vSize = {0, 0};
+ DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+ HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
+ HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
+ POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
+ 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
+ };
+
+ if (m_hMaskBitmap)
+ {
+ ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
+ m_hMaskBitmap = 0;
+ }
+ if (!rBitmap.Ok())
+ {
+ return(FALSE);
+ }
-/*
- * wxBitmapHandler
- */
+ //
+ // Scan the bitmap for the transparent colour and set
+ // the corresponding pixels in the mask to BLACK and
+ // the rest to WHITE
+ //
+
+ memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+ vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
+ vBmih.cx = rBitmap.GetWidth();
+ vBmih.cy = rBitmap.GetHeight();
+ vBmih.cPlanes = 1;
+ vBmih.cBitCount = 1;
+
+ m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
+ ,&vBmih
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
+ ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
+
+ //
+ // This is not very efficient, but I can't think
+ // of a better way of doing it
+ //
+ for (int w = 0; w < rBitmap.GetWidth(); w++)
+ {
+ for (int h = 0; h < rBitmap.GetHeight(); h++)
+ {
+ POINTL vPt = {w, h};
+ COLORREF vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
+ if (vCol == (COLORREF)CLR_NOINDEX)
+ {
+ //
+ // Doesn't make sense to continue
+ //
+ bOk = FALSE;
+ break;
+ }
+
+ if (vCol == vMaskColour)
+ {
+ ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
+ ::GpiSetPel(hPSDst, &vPt);
+ }
+ else
+ {
+ ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
+ ::GpiSetPel(hPSDst, &vPt);
+ }
+ }
+ }
+ ::GpiSetBitmap(hPSSrc, NULL);
+ ::GpiSetBitmap(hPSDst, NULL);
+ ::GpiDestroyPS(hPSSrc);
+ ::GpiDestroyPS(hPSDst);
+ ::DevCloseDC(hDCSrc);
+ ::DevCloseDC(hDCDst);
+ return(TRUE);
+} // end of wxMask::Create
+
+// ----------------------------------------------------------------------------
+// wxBitmapHandler
+// ----------------------------------------------------------------------------
+
+bool wxBitmapHandler::Create(
+ wxGDIImage* pImage
+, void* pData
+, long lFlags
+, int nWidth
+, int nHeight
+, int nDepth
+)
+{
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
+
+ return(pBitmap ? Create( pBitmap
+ ,pData
+ ,nWidth
+ ,nHeight
+ ,nDepth
+ ) : FALSE);
+}
-IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
+bool wxBitmapHandler::Load(
+ wxGDIImage* pImage
+, const wxString& rName
+, HPS hPs
+, long lFlags
+, int nWidth
+, int nHeight
+)
+{
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
+
+ return(pBitmap ? LoadFile( pBitmap
+ ,rName
+ ,hPs
+ ,lFlags
+ ,nWidth
+ ,nHeight
+ ) : FALSE);
+}
-bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
+bool wxBitmapHandler::Save(
+ wxGDIImage* pImage
+, const wxString& rName
+, int lType
+)
{
- return FALSE;
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
+
+ return(pBitmap ? SaveFile( pBitmap
+ ,rName
+ ,lType
+ ) : FALSE);
}
-bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
- int desiredWidth, int desiredHeight)
+bool wxBitmapHandler::Create(
+ wxBitmap* WXUNUSED(pBitmap)
+, void* WXUNUSED(pData)
+, long WXUNUSED(lType)
+, int WXUNUSED(nWidth)
+, int WXUNUSED(nHeight)
+, int WXUNUSED(nDepth)
+)
{
- return FALSE;
+ return(FALSE);
}
-bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
+bool wxBitmapHandler::LoadFile(
+ wxBitmap* WXUNUSED(pBitmap)
+, const wxString& WXUNUSED(rName)
+, HPS WXUNUSED(hPs)
+, long WXUNUSED(lType)
+, int WXUNUSED(nDesiredWidth)
+, int WXUNUSED(nDesiredHeight)
+)
{
- return FALSE;
+ return(FALSE);
}
-/*
- * Standard handlers
- */
+bool wxBitmapHandler::SaveFile(
+ wxBitmap* WXUNUSED(pBitmap)
+, const wxString& WXUNUSED(rName)
+, int WXUNUSED(nType)
+, const wxPalette* WXUNUSED(pPalette)
+)
+{
+ return(FALSE);
+}
-/* TODO: bitmap handlers, a bit like this:
-class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
+// ----------------------------------------------------------------------------
+// Utility functions
+// ----------------------------------------------------------------------------
+HBITMAP wxInvertMask(
+ HBITMAP hBmpMask
+, int nWidth
+, int nHeight
+)
{
- DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
-public:
- inline wxBMPResourceHandler()
- {
- m_name = "Windows bitmap resource";
- m_extension = "";
- m_type = wxBITMAP_TYPE_BMP_RESOURCE;
- };
+ HBITMAP hBmpInvMask = 0;
- virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
- int desiredWidth, int desiredHeight);
-};
-IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
-*/
+ wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
-void wxBitmap::CleanUpHandlers()
-{
- wxNode *node = sm_handlers.First();
- while ( node )
+ //
+ // Get width/height from the bitmap if not given
+ //
+ if (!nWidth || !nHeight)
{
- wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
- wxNode *next = node->Next();
- delete handler;
- delete node;
- node = next;
+ BITMAPINFOHEADER2 vBmhdr;
+
+ ::GpiQueryBitmapInfoHeader( hBmpMask
+ ,&vBmhdr
+ );
+ nWidth = (int)vBmhdr.cx;
+ nHeight = (int)vBmhdr.cy;
}
-}
-void wxBitmap::InitStandardHandlers()
-{
-/* TODO: initialize all standard bitmap or derive class handlers here.
- AddHandler(new wxBMPResourceHandler);
- AddHandler(new wxBMPFileHandler);
- AddHandler(new wxXPMFileHandler);
- AddHandler(new wxXPMDataHandler);
- AddHandler(new wxICOResourceHandler);
- AddHandler(new wxICOFileHandler);
-*/
-}
+ BITMAPINFOHEADER2 vBmih;
+ SIZEL vSize = {0, 0};
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
+ HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
+ HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
+ POINTL vPoint[4] = { 0 ,0, nWidth, nHeight,
+ 0, 0, nWidth, nHeight
+ };
+
+ memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
+ vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
+ vBmih.cx = nWidth;
+ vBmih.cy = nHeight;
+ vBmih.cPlanes = 1;
+ vBmih.cBitCount = 1;
+
+ hBmpInvMask = ::GpiCreateBitmap( hPSDst
+ ,&vBmih
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
+ ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
+
+ ::GpiBitBlt( hPSDst
+ ,hPSSrc
+ ,4L
+ ,vPoint
+ ,ROP_SRCINVERT
+ ,BBO_IGNORE
+ );
+
+ ::GpiDestroyPS(hPSSrc);
+ ::GpiDestroyPS(hPSDst);
+ ::DevCloseDC(hDCSrc);
+ ::DevCloseDC(hDCDst);
+
+ return hBmpInvMask;
+} // end of WxWinGdi_InvertMask
projects / wxWidgets.git / blobdiff