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

bitmap and image updates

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4800 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-12-03 05:03:55 +00:00
parent d01cc696fc
commit 3b9e345522
11 changed files with 1091 additions and 811 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/os2/app.h
View File

@@ -22,6 +22,7 @@ class WXDLLEXPORT wxKeyEvent;
class WXDLLEXPORT wxLog;
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
HAB vHabmain;
// Force an exit from main loop
void WXDLLEXPORT wxExit(void);
@@ -100,7 +101,6 @@ protected:
DECLARE_EVENT_TABLE()
private:
HAB m_vHab;
HMQ m_hMq;
QMSG m_vMsg;
};

461
include/wx/os2/bitmap.h
View File

@@ -1,9 +1,9 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.h
// Name: wx/os2/bitmap.h
// Purpose: wxBitmap class
// Author: David Webster
// Modified by:
// Created: 10/13/99
// Created: 11/28/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
@@ -12,196 +12,337 @@
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/gdiobj.h"
#ifdef __GNUG__
#pragma interface "bitmap.h"
#endif
#include "wx/os2/gdiimage.h"
#include "wx/gdicmn.h"
#include "wx/palette.h"
// Bitmap
class WXDLLEXPORT wxDC;
class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxBitmapHandler;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxMask;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxControl;
// A mask is a mono bitmap used for drawing bitmaps
// transparently.
// ----------------------------------------------------------------------------
// Bitmap data
//
// NB: this class is private, but declared here to make it possible inline
// wxBitmap functions accessing it
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
{
public:
wxBitmapRefData();
virtual ~wxBitmapRefData() { Free(); }
virtual void Free();
public:
int m_nNumColors;
wxPalette m_vBitmapPalette;
int m_nQuality;
// OS2-specific
// ------------
wxDC* m_pSelectedInto;
HPS m_hPresentationSpace;
// optional mask for transparent drawing
wxMask* m_pBitmapMask;
};
// ----------------------------------------------------------------------------
// wxBitmap: a mono or colour bitmap
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmap : public wxGDIImage
{
public:
// default ctor creates an invalid bitmap, you must Create() it later
wxBitmap() { Init(); }
// Copy constructors
inline wxBitmap(const wxBitmap& rBitmap)
{ Init(); Ref(rBitmap); }
// Initialize with raw data
wxBitmap( const char bits[]
,int nWidth
,int nHeight
,int nDepth = 1
);
// Initialize with XPM data
wxBitmap( char** ppData
,wxControl* pAnItem = NULL
);
// Load a file or resource
wxBitmap( const wxString& rName
,long lType = wxBITMAP_TYPE_BMP_RESOURCE
);
// New constructor for generalised creation from data
wxBitmap( void* pData
,long lType
,int nWidth
,int nHeight
,int nDepth = 1
);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap( int nWidth
,int nHeight
,int nDepth = -1
);
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
inline wxBitmap(const wxIcon& rIcon)
{ Init(); CopyFromIcon(rIcon); }
wxBitmap& operator=(const wxBitmap& rBitmap)
{
if ( m_refData != rBitmap.m_refData )
Ref(rBitmap);
return(*this);
}
wxBitmap& operator=(const wxIcon& rIcon)
{
(void)CopyFromIcon(rIcon);
return(*this);
}
wxBitmap& operator=(const wxCursor& rCursor)
{
(void)CopyFromCursor(rCursor);
return (*this);
}
virtual ~wxBitmap();
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& rIcon);
// copies the contents and mask of the given cursor to the bitmap
bool CopyFromCursor(const wxCursor& rCursor);
virtual bool Create( int nWidth
,int nHeight
,int nDepth = -1
);
virtual bool Create( void* pData
,long lType
,int nWidth
,int nHeight
,int nDepth = 1
);
virtual bool LoadFile( const wxString& rName
,long lType = wxBITMAP_TYPE_BMP_RESOURCE
);
virtual bool SaveFile( const wxString& rName
,int lType
,const wxPalette* pCmap = NULL
);
inline wxBitmapRefData* GetBitmapData() const
{ return (wxBitmapRefData *)m_refData; }
inline int GetQuality() const
{ return (GetBitmapData() ? GetBitmapData()->m_quality : 0); }
void SetQuality(int nQ);
wxPalette* GetPalette() const
{ return (GetBitmapData() ? (& GetBitmapData()->m_bitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& rPalette);
inline wxMask* GetMask() const
{ return (GetBitmapData() ? GetBitmapData()->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask* pMask) ;
inline bool operator==(const wxBitmap& rBitmap)
{ return m_refData == rBitmap.m_refData; }
inline bool operator!=(const wxBitmap& rBitmap)
{ return m_refData != rBitmap.m_refData; }
#if WXWIN_COMPATIBILITY_2
void SetOk(bool bIsOk);
#endif // WXWIN_COMPATIBILITY_2
#if WXWIN_COMPATIBILITY
inline wxPalette* GetColourMap() const
{ return GetPalette(); }
inline void SetColourMap(wxPalette* pCmap)
{ SetPalette(*pCmap); };
#endif // WXWIN_COMPATIBILITY
// Implementation
public:
inline void SetHBITMAP(WXHBITMAP hHmp)
{ SetHandle((WXHANDLE)bmp); }
inline WXHBITMAP GetHBITMAP() const
{ return (WXHBITMAP)GetHandle(); }
inline void SetSelectedInto(wxDC* pDc)
{ if (GetBitmapData()) GetBitmapData()->m_selectedInto = pDc; }
inline wxDC* GetSelectedInto() const
{ return (GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC*) NULL); }
// Creates a bitmap that matches the device context's depth, from an
// arbitray bitmap. At present, the original bitmap must have an associated
// palette. (TODO: use a default palette if no palette exists.) This
// function is necessary for you to Blit an arbitrary bitmap (which may
// have the wrong depth). wxDC::SelectObject will compare the depth of the
// bitmap with the DC's depth, and create a new bitmap if the depths
// differ. Eventually we should perhaps make this a public API function so
// that an app can efficiently produce bitmaps of the correct depth. The
// Windows solution is to use SetDibBits to blit an arbotrary DIB directly
// to a DC, but this is too Windows-specific, hence this solution of
// quietly converting the wxBitmap. Contributed by Frederic Villeneuve
// <frederic.villeneuve@natinst.com>
wxBitmap GetBitmapForDC(wxDC& rDc) const;
protected:
// common part of all ctors
void Init();
inline virtual wxGDIImageRefData* CreateData() const
{ return new wxBitmapRefData; }
private:
bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
DECLARE_DYNAMIC_CLASS(wxBitmap)
};
// ----------------------------------------------------------------------------
// wxMask: a mono bitmap used for drawing bitmaps transparently.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMask : public wxObject
{
DECLARE_DYNAMIC_CLASS(wxMask)
public:
wxMask();
// Construct a mask from a bitmap and a colour indicating
// the transparent area
wxMask(const wxBitmap& bitmap, const wxColour& colour);
// Construct a mask from a bitmap and a colour indicating the transparent
// area
wxMask( const wxBitmap& rBitmap
,const wxColour& rColour
);
// Construct a mask from a bitmap and a palette index indicating
// the transparent area
wxMask(const wxBitmap& bitmap, int paletteIndex);
// Construct a mask from a bitmap and a palette index indicating the
// transparent area
wxMask( const wxBitmap& rBitmap
,int nPaletteIndex
);
// Construct a mask from a mono bitmap (copies the bitmap).
wxMask(const wxBitmap& bitmap);
wxMask(const wxBitmap& rBitmap);
~wxMask();
// construct a mask from the givne bitmap handle
wxMask(WXHBITMAP hBmp)
{ m_hMaskBitmap = hBmp; }
bool Create(const wxBitmap& bitmap, const wxColour& colour);
bool Create(const wxBitmap& bitmap, int paletteIndex);
bool Create(const wxBitmap& bitmap);
virtual ~wxMask();
bool Create( const wxBitmap& bitmap
,const wxColour& rColour
);
bool Create( const wxBitmap& rBitmap
,int nPaletteIndex
);
bool Create(const wxBitmap& rBitmap);
// Implementation
inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
WXHBITMAP GetMaskBitmap() const
{ return m_hMaskBitmap; }
void SetMaskBitmap(WXHBITMAP hBmp)
{ m_hMaskBitmap = hBmp; }
protected:
WXHBITMAP m_maskBitmap;
WXHBITMAP m_hMaskBitmap;
DECLARE_DYNAMIC_CLASS(wxMask)
};
class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData
// ----------------------------------------------------------------------------
// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
{
friend class WXDLLEXPORT wxBitmap;
friend class WXDLLEXPORT wxIcon;
friend class WXDLLEXPORT wxCursor;
public:
wxBitmapRefData();
~wxBitmapRefData();
inline wxBitmapHandler()
{ m_lType = wxBITMAP_TYPE_INVALID; }
public:
int m_width;
int m_height;
int m_depth;
bool m_ok;
int m_numColors;
wxPalette m_bitmapPalette;
int m_quality;
WXHBITMAP m_hBitmap;
wxDC * m_selectedInto; // So bitmap knows whether it's been selected into
wxMask * m_bitmapMask; // Optional mask
};
#define M_BITMAPDATA ((wxBitmapRefData *)m_refData)
class WXDLLEXPORT wxBitmapHandler: public wxObject
inline wxBitmapHandler( const wxString& rName
,const wxString& rExt
,long lType
)
: wxGDIImageHandler( rName
,rExt
,lType)
{
}
// keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
// old class which worked only with bitmaps
virtual bool Create( wxBitmap* pBitmap
,void* pData
,long lFlags
,int nWidth
,int nHeight
,int nDepth = 1
);
virtual bool LoadFile( wxBitmap* pBitmap
,const wxString& rName
,long lFlags
,int nDesiredWidth
,int nDesiredHeight
);
virtual bool SaveFile( wxBitmap* pBitmap
,const wxString& rName
,int lType
,const wxPalette* pPalette = NULL
);
virtual bool Create( wxGDIImage* pImage
,void* pData
,long lFlags
,int nWidth
,int nHeight
,int nDepth = 1
);
virtual bool Load( wxGDIImage* pImage
,const wxString& rName
,long lFlags
,int nDesiredWidth
,int nDesiredHeight
);
virtual bool Save(wxGDIImage* pImage
const wxString& rName
int lType
);
private:
DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
public:
wxBitmapHandler() { m_name = ""; m_extension = ""; m_type = 0; };
virtual bool Create(wxBitmap *bitmap, void *data, long flags, int width, int height, int depth = 1);
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette = NULL);
inline void SetName(const wxString& name) { m_name = name; }
inline void SetExtension(const wxString& ext) { m_extension = ext; }
inline void SetType(long type) { m_type = type; }
inline wxString GetName() const { return m_name; }
inline wxString GetExtension() const { return m_extension; }
inline long GetType() const { return m_type; }
protected:
wxString m_name;
wxString m_extension;
long m_type;
};
#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
class WXDLLEXPORT wxBitmap: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxBitmap)
friend class WXDLLEXPORT wxBitmapHandler;
public:
wxBitmap(); // Platform-specific
// Copy constructors
wxBitmap(const wxBitmap& bitmap);
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(char **data, wxControl *anItem = NULL);
// Load a file or resource
wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
// New constructor for generalised creation from data
wxBitmap(void *data, long type, int width, int height, int depth = 1);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1);
~wxBitmap();
virtual bool Create(int width, int height, int depth = -1);
virtual bool Create(void *data, long type, int width, int height, int depth = 1);
virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
inline bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
inline int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
inline int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
inline int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
inline int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
void SetWidth(int w);
void SetHeight(int h);
void SetDepth(int d);
void SetQuality(int q);
void SetOk(bool isOk);
#if WXWIN_COMPATIBILITY
inline wxPalette *GetColourMap(void) const { return GetPalette(); }
void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
#endif
inline wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& palette);
inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask *mask) ;
inline wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; }
inline bool operator == (const wxBitmap& bitmap) { return m_refData == bitmap.m_refData; }
inline bool operator != (const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; }
// Format handling
static inline wxList& GetHandlers() { return sm_handlers; }
static void AddHandler(wxBitmapHandler *handler);
static void InsertHandler(wxBitmapHandler *handler);
static bool RemoveHandler(const wxString& name);
static wxBitmapHandler *FindHandler(const wxString& name);
static wxBitmapHandler *FindHandler(const wxString& extension, long bitmapType);
static wxBitmapHandler *FindHandler(long bitmapType);
static void InitStandardHandlers();
static void CleanUpHandlers();
protected:
static wxList sm_handlers;
// Implementation
public:
void SetHBITMAP(WXHBITMAP bmp);
inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
inline void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; }
inline wxDC *GetSelectedInto(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_selectedInto : (wxDC*) NULL); }
bool FreeResource(bool force = FALSE);
// Creates a bitmap that matches the device context's depth, from
// an arbitray bitmap. At present, the original bitmap must have an
// associated palette. (TODO: use a default palette if no palette exists.)
// This function is necessary for you to Blit an arbitrary bitmap (which may have
// the wrong depth). wxDC::SelectObject will compare the depth of the bitmap
// with the DC's depth, and create a new bitmap if the depths differ.
// Eventually we should perhaps make this a public API function so that
// an app can efficiently produce bitmaps of the correct depth.
// The Windows solution is to use SetDibBits to blit an arbotrary DIB directly to a DC, but
// this is too Windows-specific, hence this solution of quietly converting the wxBitmap.
// Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
wxBitmap GetBitmapForDC(wxDC& dc) const;
};
#endif
// _WX_BITMAP_H_

124
include/wx/os2/icon.h
View File

@@ -12,91 +12,89 @@
#ifndef _WX_ICON_H_
#define _WX_ICON_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// compatible (even if incorrect) behaviour by default: derive wxIcon from
// wxBitmap
#ifndef wxICON_IS_BITMAP
#define wxICON_IS_BITMAP 1
#endif
#if wxICON_IS_BITMAP
#include "wx/bitmap.h"
class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
{
friend class WXDLLEXPORT wxBitmap;
friend class WXDLLEXPORT wxIcon;
public:
wxIconRefData();
~wxIconRefData();
#define wxIconRefDataBase wxBitmapRefData
#define wxIconBase wxBitmap
#else
#include "wx/os2/gdiimage.h"
#define wxIconRefDataBase wxGDIImageRefData
#define wxIconBase wxGDIImage
#endif
class WXDLLEXPORT wxIconRefData: public wxIconRefDataBase
{
public:
wxIconRefData() { };
virtual ~wxIconRefData() { Free(); m_hIcon = NULL; }
virtual void Free();
public:
WXHICON m_hIcon;
};
#define M_ICONDATA ((wxIconRefData *)m_refData)
#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData())
// ---------------------------------------------------------------------------
// Icon
class WXDLLEXPORT wxIcon: public wxBitmap
{
DECLARE_DYNAMIC_CLASS(wxIcon)
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxIcon: public wxIconBase
{
public:
wxIcon();
// Copy constructors
inline wxIcon(const wxIcon& icon) { Ref(icon); }
wxIcon(const char bits[], int width, int height);
wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1);
wxIcon( const char bits[]
,int nWidth
,int nHeight
);
wxIcon( const wxString& rName
,long lFlags = wxBITMAP_TYPE_ICO_RESOURCE
,int nDesiredWidth = -1
,int nDesiredHeight = -1
);
~wxIcon();
bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE,
int desiredWidth = -1, int desiredHeight = -1);
bool LoadFile( const wxString& rName
,long lFlags = wxBITMAP_TYPE_ICO_RESOURCE
,int nDesiredWidth = -1
,int nDesiredHeight = -1
);
inline wxIcon& operator = (const wxIcon& icon) { if (*this == icon) return (*this); Ref(icon); return *this; }
inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
inline wxIcon& operator = (const wxIcon& rIcon)
{ if (*this == rIcon) Ref(rIcon); return *this; }
inline bool operator == (const wxIcon& rIcon)
{ return m_refData == rIcon.m_refData; }
inline bool operator != (const wxIcon& rIcon)
{ return m_refData != rIcon.m_refData; }
void SetHICON(WXHICON ico);
inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
inline void SetHICON(WXHICON hIcon) { SetHandle((WXHANDLE)hIcon); }
inline WXHICON GetHICON() const { return (WXHICON)GetHandle(); }
protected:
virtual wxGDIImageRefData* CreateData() const
{
return new wxIconRefData;
}
virtual bool Ok() const { return (m_refData != NULL) ; }
private:
// supress virtual function hiding warning
virtual bool LoadFile( const wxString& name
,long type = wxBITMAP_TYPE_BMP_RESOURCE
)
{ return(wxBitmap::LoadFile(name, type)); };
};
// Example handlers. TODO: write your own handlers for relevant types.
class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler
{
DECLARE_DYNAMIC_CLASS(wxICOFileHandler)
public:
inline wxICOFileHandler()
{
m_name = "ICO icon file";
m_extension = "ico";
m_type = wxBITMAP_TYPE_ICO;
};
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth = -1, int desiredHeight = -1);
};
class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler
{
DECLARE_DYNAMIC_CLASS(wxICOResourceHandler)
public:
inline wxICOResourceHandler()
{
m_name = "ICO resource";
m_extension = "ico";
m_type = wxBITMAP_TYPE_ICO_RESOURCE;
};
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth = -1, int desiredHeight = -1);
DECLARE_DYNAMIC_CLASS(wxIcon)
};
#endif
// _WX_ICON_H_

3
include/wx/os2/setup.h
View File

@@ -16,6 +16,9 @@
// global settings
// ----------------------------------------------------------------------------
// define this to 1 if you want icons to behave as bitmaps
#define wxICON_IS_BITMAP 0
// define this to 0 when building wxBase library
#define wxUSE_GUI 1

3
include/wx/os2/setup0.h
View File

@@ -16,6 +16,9 @@
// global settings
// ----------------------------------------------------------------------------
// define this to 1 if you want icons to behave as bitmaps
#define wxICON_IS_BITMAP 0
// define this to 0 when building wxBase library
#define wxUSE_GUI 1

64
include/wx/os2/statbmp.h
View File

@@ -1,11 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.h
// Purpose: wxStaticBitmap class
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 11/27/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -17,6 +17,7 @@
#endif
#include "wx/control.h"
#include "wx/icon.h"
WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr;
@@ -24,54 +25,57 @@ class WXDLLEXPORT wxStaticBitmap: public wxControl
{
DECLARE_DYNAMIC_CLASS(wxStaticBitmap)
public:
inline wxStaticBitmap() { }
inline wxStaticBitmap() { Init(); }
inline wxStaticBitmap(wxWindow *parent, wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
inline wxStaticBitmap( wxWindow* pParent
,wxWindowID nId
,const wxGDIImage& rLabel
,const wxPoint& rPos = wxDefaultPosition
,const wxSize& rSize = wxDefaultSize
,long lStyle = 0
,const wxString& rName = wxStaticBitmapNameStr
)
{
Create(parent, id, label, pos, size, style, name);
Create(pParent, nId, rLabel, rPos, rSize, lStyle, rName);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
bool Create( wxWindow* pParent
,wxWindowID nId
,const wxGDIImage& rLabel
,const wxPoint& rPos = wxDefaultPosition
,const wxSize& rSize = wxDefaultSize
,long lStyle = 0
,const wxString& rName = wxStaticBitmapNameStr
);
inline virtual ~wxStaticBitmap() { Free(); }
virtual void SetIcon(const wxIcon& icon) { SetBitmap(icon); }
virtual void SetBitmap(const wxBitmap& bitmap);
virtual void SetIcon(const wxIcon& rIcon) { SetImage(rIcon); }
virtual void SetBitmap(const wxBitmap& rBitmap) { SetImage(rBitmap); };
// assert failure is provoked by an attempt to get an icon from bitmap or
// vice versa
const wxIcon& GetIcon() const
{ wxASSERT( m_isIcon ); return *m_image.icon; }
{ wxASSERT( m_bIsIcon ); return *(wxIcon *)m_pImage; }
const wxBitmap& GetBitmap() const
{ wxASSERT( !m_isIcon ); return *m_image.bitmap; }
{ wxASSERT( !m_bIsIcon ); return *(wxBitmap *)m_pImage; }
// overriden base class virtuals
virtual bool AcceptsFocus() const { return FALSE; }
protected:
void Init() { m_isIcon = TRUE; m_image.icon = NULL; }
virtual wxSize DoGetBestSize() const;
void Init() { m_bIsIcon = TRUE; m_pImage = NULL; }
void Free();
// TRUE if icon/bitmap is valid
bool ImageIsOk() const;
// we can have either an icon or a bitmap
bool m_isIcon;
union
{
wxIcon *icon;
wxBitmap *bitmap;
} m_image;
void SetImage(const wxGDIImage& rImage);
virtual wxSize DoGetBestSize() const;
// we can have either an icon or a bitmap
bool m_bIsIcon;
wxGDIImage* m_pImage;
};
#endif

5
src/os2/app.cpp
View File

@@ -185,13 +185,14 @@ bool wxApp::RegisterWindowClasses(
HAB vHab
)
{
APIRET rc;
if (!::WinRegisterClass( vHab
if ((rc = ::WinRegisterClass( vHab
,wxFrameClassName
,(PFNWP)wxWndProc
,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME
,0
))
)) != 0)
{
wxLogLastError("RegisterClass(frame)");

806
src/os2/bitmap.cpp
View File

@@ -27,6 +27,9 @@
#include "wx/os2/private.h"
#include "wx/log.h"
//#include "wx/msw/dib.h"
#include "wx/image.h"
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
@@ -34,76 +37,104 @@
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
#endif
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxBitmapRefData
// ----------------------------------------------------------------------------
wxBitmapRefData::wxBitmapRefData()
{
m_ok = FALSE;
m_width = 0;
m_height = 0;
m_depth = 0;
m_quality = 0;
m_hBitmap = 0 ;
m_selectedInto = NULL;
m_numColors = 0;
m_bitmapMask = NULL;
m_nQuality = 0;
m_pSelectedInto = NULL;
m_nNumColors = 0;
m_pBitmapMask = NULL;
}
wxBitmapRefData::~wxBitmapRefData()
void wxBitmapRefData::Free()
{
if (m_selectedInto)
{
wxChar buf[200];
wxSprintf(buf, wxT("Bitmap was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) m_selectedInto);
wxFatalError(buf);
}
wxASSERT_MSG( !m_pSelectedInto,
wxT("deleting bitmap still selected into wxMemoryDC") );
if (m_hBitmap)
{
// TODO: DeleteObject((HBITMAP) m_hBitmap);
}
m_hBitmap = 0 ;
if (m_bitmapMask)
delete m_bitmapMask;
m_bitmapMask = NULL;
}
wxList wxBitmap::sm_handlers;
wxBitmap::wxBitmap()
if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
{
m_refData = NULL;
wxLogLastError("GpiDeleteBitmap(hbitmap)");
}
}
delete m_pBitmapMask;
m_pBitmapMask = NULL;
}
// ----------------------------------------------------------------------------
// wxBitmap creation
// ----------------------------------------------------------------------------
// this function should be called from all wxBitmap ctors
void wxBitmap::Init()
{
// m_refData = NULL; done in the base class ctor
if (wxTheBitmapList)
wxTheBitmapList->AddBitmap(this);
}
wxBitmap::wxBitmap(const wxBitmap& bitmap)
bool wxBitmap::CopyFromIconOrCursor(
const wxGDIImage& rIcon
)
{
// TODO:
/*
wxIcon *icon = wxDynamicCast(&bitmap, wxIcon);
if ( icon )
{
HDC hdc = ::CreateCompatibleDC(NULL); // screen DC
HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc,
icon->GetWidth(),
icon->GetHeight());
::SelectObject(hdc, hbitmap);
::DrawIcon(hdc, 0, 0, (HICON)icon->GetHICON());
wxBitmapRefData* pRefData = new wxBitmapRefData;
::DeleteDC(hdc);
m_refData = pRefData;
SetHBITMAP((WXHBITMAP)hbitmap);
}
else
{
Ref(bitmap);
refData->m_width = rIcon.GetWidth();
refData->m_height = rIcon.GetHeight();
refData->m_depth = wxDisplayDepth();
refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
// no mask???
refData->m_bitmapMask = new wxMask();
#if WXWIN_COMPATIBILITY_2
refData->m_ok = TRUE;
#endif // WXWIN_COMPATIBILITY_2
return(TRUE);
}
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
*/
bool wxBitmap::CopyFromCursor(
const wxCursor& rCursor
)
{
UnRef();
if (!rCursor.Ok())
return(FALSE);
return CopyFromIconOrCursor(wxGDIImage)rCursor);
}
bool wxBitmap::CopyFromIcon(
const wxIcon& rIcon
)
{
UnRef();
if (!rIcon.Ok())
return(FALSE);
#if WXWIN_COMPATIBILITY_2
refData->m_ok = TRUE;
#endif // WXWIN_COMPATIBILITY_2
return CopyFromIconOrCursor(icon);
}
wxBitmap::~wxBitmap()
@@ -112,265 +143,299 @@ wxBitmap::~wxBitmap()
wxTheBitmapList->DeleteObject(this);
}
bool wxBitmap::FreeResource(bool WXUNUSED(force))
wxBitmap::wxBitmap(
const char zBits[]
, int nTheWidth
, int nTheHeight
, int nNoBits
)
{
if ( !M_BITMAPDATA )
return FALSE;
Init();
if (M_BITMAPDATA->m_selectedInto)
wxBitmapRefData* pRefData = new wxBitmapRefData;
BITMAPINFOHEADER2 vHeader;
BITMAPINFO2 vInfo;
HDC hDc;
HPS hPs;
DEVOPENSTRUCT 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;
vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
if (vhPs == 0)
{
wxChar buf[200];
wxSprintf(buf, wxT("Bitmap %lX was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) this, (unsigned long) M_BITMAPDATA->m_selectedInto);
wxFatalError(buf);
}
if (M_BITMAPDATA->m_hBitmap)
{
// TODO: DeleteObject((HBITMAP) M_BITMAPDATA->m_hBitmap);
}
M_BITMAPDATA->m_hBitmap = 0 ;
/*
if (M_BITMAPDATA->m_bitmapPalette)
delete M_BITMAPDATA->m_bitmapPalette;
M_BITMAPDATA->m_bitmapPalette = NULL ;
*/
return TRUE;
wxLogLastError("GpiCreatePS Failure");
}
m_refData = pRefData;
wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
refData->m_width = nTheWidth;
refData->m_height = nTheHeight;
refData->m_depth = nNoBits;
refData->m_numColors = 0;
refData->m_selectedInto = NULL;
HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
if ( !hbmp )
{
m_refData = 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;
/* TODO: create the bitmap from data */
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
wxLogLastError("CreateBitmap");
}
SetHBITMAP((WXHBITMAP)hbmp);
}
// Create from XPM data
wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem))
wxBitmap::wxBitmap(
char** ppData
, wxControl* WXUNUSED(pAnItem))
{
(void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
Init();
F (void)Create( (void *)ppData
,wxBITMAP_TYPE_XPM_DATA
,0
,0
,0
);
}
wxBitmap::wxBitmap(int w, int h, int d)
wxBitmap::wxBitmap(
int nW
, int nH
, int nD
)
{
(void)Create(w, h, d);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
(void)Create( nW
,nH
,nD
);
}
wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
wxBitmap::wxBitmap(
void* pData
, long lType
, int nWidth
, int nHeight
, int nDepth
)
{
(void) Create(data, type, width, height, depth);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
(void)Create( pData
,lType
,nWidth
,nHeight
,nDepth
);
}
wxBitmap::wxBitmap(const wxString& filename, long type)
wxBitmap::wxBitmap(
const wxString& rFilename
, long lType
)
{
LoadFile(filename, (int)type);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
LoadFile( rFilename
,(int)lType
);
}
bool wxBitmap::Create(int w, int h, int d)
bool wxBitmap::Create(
int nW
, int nH
, int nD
)
{
HBITMAP hBmp;
BITMAPINFOHEADER2 vHeader;
BITMAPINFO2 vInfo;
HDC hDc;
HPS hPs;
DEVOPENSTRUCT 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)nW;
vHeader.cy = (USHORT)nH;
vHeader.cPlanes = (USHORT)nD;
vHeader.cBitCount = 24;
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;
vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
if (vhPs == 0)
{
wxLogLastError("GpiCreatePS Failure");
}
UnRef();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_width = w;
M_BITMAPDATA->m_height = h;
M_BITMAPDATA->m_depth = d;
GetBitmapData()->m_width = nW;
GetBitmapData()->m_height = nH;
GetBitmapData()->m_depth = nD;
/* TODO: create new bitmap */
if (nD > 0)
{
hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
if (!hBmp)
{
wxLogLastError("CreateBitmap");
}
}
else
{
ScreenHDC dc;
hbmp = ::CreateCompatibleBitmap(dc, w, h);
if ( !hbmp )
{
wxLogLastError("CreateCompatibleBitmap");
}
return M_BITMAPDATA->m_ok;
GetBitmapData()->m_depth = wxDisplayDepth();
}
SetHBITMAP((WXHBITMAP)hbmp);
#if WXWIN_COMPATIBILITY_2
GetBitmapData()->m_ok = hbmp != 0;
#endif // WXWIN_COMPATIBILITY_2
return Ok();
}
bool wxBitmap::LoadFile(const wxString& filename, long type)
{
UnRef();
wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
if ( handler )
{
m_refData = new wxBitmapRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
return handler->LoadFile(this, filename, type, -1, -1);
}
else
{
wxImage image;
if ( !image.LoadFile( filename, type ) || !image.Ok() )
return FALSE;
*this = image.ConvertToBitmap();
return TRUE;
}
}
bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
{
UnRef();
m_refData = new wxBitmapRefData;
wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
if ( !handler )
{
wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
"type %d defined."), type);
return FALSE;
}
m_refData = new wxBitmapRefData;
return handler->Create(this, data, type, width, height, depth);
}
bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
{
wxBitmapHandler *handler = FindHandler(type);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
if ( handler )
{
return handler->SaveFile(this, filename, type, palette);
}
void wxBitmap::SetWidth(int w)
else
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
// FIXME what about palette? shouldn't we use it?
wxImage image( *this );
if (!image.Ok())
return FALSE;
M_BITMAPDATA->m_width = w;
return image.SaveFile( filename, type );
}
}
void wxBitmap::SetHeight(int h)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_height = h;
}
void wxBitmap::SetDepth(int d)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_depth = d;
}
// ----------------------------------------------------------------------------
// wxBitmap accessors
// ----------------------------------------------------------------------------
void wxBitmap::SetQuality(int q)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
EnsureHasData();
M_BITMAPDATA->m_quality = q;
GetBitmapData()->m_quality = q;
}
#if WXWIN_COMPATIBILITY_2
void wxBitmap::SetOk(bool isOk)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
EnsureHasData();
M_BITMAPDATA->m_ok = isOk;
GetBitmapData()->m_ok = isOk;
}
#endif // WXWIN_COMPATIBILITY_2
void wxBitmap::SetPalette(const wxPalette& palette)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
EnsureHasData();
M_BITMAPDATA->m_bitmapPalette = palette ;
GetBitmapData()->m_bitmapPalette = palette;
}
void wxBitmap::SetMask(wxMask *mask)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
EnsureHasData();
M_BITMAPDATA->m_bitmapMask = mask ;
}
void wxBitmap::SetHBITMAP(WXHBITMAP bmp)
{
if (!M_BITMAPDATA)
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_hBitmap = bmp;
}
void wxBitmap::AddHandler(wxBitmapHandler *handler)
{
sm_handlers.Append(handler);
}
void wxBitmap::InsertHandler(wxBitmapHandler *handler)
{
sm_handlers.Insert(handler);
}
bool wxBitmap::RemoveHandler(const wxString& name)
{
wxBitmapHandler *handler = FindHandler(name);
if ( handler )
{
sm_handlers.DeleteObject(handler);
return TRUE;
}
else
return FALSE;
}
wxBitmapHandler *wxBitmap::FindHandler(const wxString& name)
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
if ( handler->GetName() == name )
return handler;
node = node->Next();
}
return NULL;
}
wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType)
{
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;
}
wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
if (handler->GetType() == bitmapType)
return handler;
node = node->Next();
}
return NULL;
GetBitmapData()->m_bitmapMask = mask;
}
// Creates a bitmap that matches the device context, from
@@ -379,29 +444,18 @@ wxBitmapHandler *wxBitmap::FindHandler(long bitmapType)
// Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
{
wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
// TODO:
/*
wxMemoryDC memDC;
wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
HPALETTE hPal = (HPALETTE) NULL;
LPBITMAPINFO lpDib;
void *lpBits = (void*) NULL;
wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) );
tmpBitmap.SetPalette(this->GetPalette());
memDC.SelectObject(tmpBitmap);
memDC.SetPalette(this->GetPalette());
hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) )
if( GetPalette() && GetPalette()->Ok() )
{
tmpBitmap.SetPalette(* this->GetPalette());
tmpBitmap.SetPalette(*GetPalette());
memDC.SelectObject(tmpBitmap);
memDC.SetPalette(* this->GetPalette());
hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
memDC.SetPalette(*GetPalette());
hPal = (HPALETTE)GetPalette()->GetHPALETTE();
}
else
{
@@ -413,26 +467,32 @@ wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
memDC.SetPalette( palette );
}
// set the height negative because in a DIB the order of the lines is reversed
createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib);
// set the height negative because in a DIB the order of the lines is
// reversed
if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
{
return wxNullBitmap;
}
lpBits = malloc(lpDib->bmiHeader.biSizeImage);
::GetBitmapBits((HBITMAP)GetHBITMAP(), lpDib->bmiHeader.biSizeImage, lpBits);
::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
::SetDIBitsToDevice((HDC) memDC.GetHDC(), 0, 0, this->GetWidth(), this->GetHeight(),
0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS);
::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
GetWidth(), GetHeight(),
0, 0, 0, GetHeight(),
lpBits, lpDib, DIB_RGB_COLORS);
free(lpBits);
freeDIB(lpDib);
*/
return (tmpBitmap);
wxFreeDIB(lpDib);
return tmpBitmap;
}
/*
* wxMask
*/
// ----------------------------------------------------------------------------
// wxMask
// ----------------------------------------------------------------------------
wxMask::wxMask()
{
@@ -464,21 +524,57 @@ wxMask::wxMask(const wxBitmap& bitmap)
wxMask::~wxMask()
{
// TODO: delete mask bitmap
if ( m_maskBitmap )
::DeleteObject((HBITMAP) m_maskBitmap);
}
// Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap)
{
// TODO
if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
if (!bitmap.Ok() || bitmap.GetDepth() != 1)
{
return FALSE;
}
m_maskBitmap = (WXHBITMAP) CreateBitmap(
bitmap.GetWidth(),
bitmap.GetHeight(),
1, 1, 0
);
HDC srcDC = CreateCompatibleDC(0);
SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
HDC destDC = CreateCompatibleDC(0);
SelectObject(destDC, (HBITMAP) m_maskBitmap);
BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
SelectObject(srcDC, 0);
DeleteDC(srcDC);
SelectObject(destDC, 0);
DeleteDC(destDC);
return TRUE;
}
// Create a mask from a bitmap and a palette index indicating
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
{
// TODO
if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
if (bitmap.Ok() && bitmap.GetPalette()->Ok())
{
unsigned char red, green, blue;
if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
{
wxColour transparentColour(red, green, blue);
return Create(bitmap, transparentColour);
}
}
return FALSE;
}
@@ -486,76 +582,164 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
// the transparent area
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{
// TODO
return FALSE;
if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
/*
* wxBitmapHandler
*/
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
if (!bitmap.Ok())
{
return FALSE;
}
bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type,
int desiredWidth, int desiredHeight)
// scan the bitmap for the transparent colour and set
// the corresponding pixels in the mask to BLACK and
// the rest to WHITE
COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
bitmap.GetWidth(),
bitmap.GetHeight(),
1, 1, 0
);
HDC srcDC = ::CreateCompatibleDC(0);
::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
HDC destDC = ::CreateCompatibleDC(0);
::SelectObject(destDC, (HBITMAP) m_maskBitmap);
// this is not very efficient, but I can't think
// of a better way of doing it
for (int w = 0; w < bitmap.GetWidth(); w++)
{
for (int h = 0; h < bitmap.GetHeight(); h++)
{
COLORREF col = GetPixel(srcDC, w, h);
if (col == maskColour)
{
::SetPixel(destDC, w, h, RGB(0, 0, 0));
}
else
{
::SetPixel(destDC, w, h, RGB(255, 255, 255));
}
}
}
::SelectObject(srcDC, 0);
::DeleteDC(srcDC);
::SelectObject(destDC, 0);
::DeleteDC(destDC);
return TRUE;
}
// ----------------------------------------------------------------------------
// wxBitmapHandler
// ----------------------------------------------------------------------------
bool wxBitmapHandler::Create(wxGDIImage *image,
void *data,
long flags,
int width, int height, int depth)
{
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
}
bool wxBitmapHandler::Load(wxGDIImage *image,
const wxString& name,
long flags,
int width, int height)
{
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
}
bool wxBitmapHandler::Save(wxGDIImage *image,
const wxString& name,
int type)
{
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
return bitmap ? SaveFile(bitmap, name, type) : FALSE;
}
bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
void *WXUNUSED(data),
long WXUNUSED(type),
int WXUNUSED(width),
int WXUNUSED(height),
int WXUNUSED(depth))
{
return FALSE;
}
bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
const wxString& WXUNUSED(name),
long WXUNUSED(type),
int WXUNUSED(desiredWidth),
int WXUNUSED(desiredHeight))
{
return FALSE;
}
/*
* Standard handlers
*/
/* TODO: bitmap handlers, a bit like this:
class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
const wxString& WXUNUSED(name),
int WXUNUSED(type),
const wxPalette *WXUNUSED(palette))
{
DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler)
public:
inline wxBMPResourceHandler()
{
m_name = "Windows bitmap resource";
m_extension = "";
m_type = wxBITMAP_TYPE_BMP_RESOURCE;
};
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight);
};
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
*/
void wxBitmap::CleanUpHandlers()
{
wxNode *node = sm_handlers.First();
while ( node )
{
wxBitmapHandler *handler = (wxBitmapHandler *)node->Data();
wxNode *next = node->Next();
delete handler;
delete node;
node = next;
}
return FALSE;
}
void wxBitmap::InitStandardHandlers()
// ----------------------------------------------------------------------------
// DIB functions
// ----------------------------------------------------------------------------
bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
{
/* 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);
*/
unsigned long i, headerSize;
LPBITMAPINFO lpDIBheader = NULL;
LPPALETTEENTRY lpPe = NULL;
// Allocate space for a DIB header
headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
lpDIBheader = (BITMAPINFO *) malloc(headerSize);
lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
GetPaletteEntries(hPal, 0, 256, lpPe);
memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
// Fill in the static parts of the DIB header
lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
lpDIBheader->bmiHeader.biWidth = xSize;
lpDIBheader->bmiHeader.biHeight = ySize;
lpDIBheader->bmiHeader.biPlanes = 1;
// this value must be 1, 4, 8 or 24 so PixelDepth can only be
lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
lpDIBheader->bmiHeader.biCompression = BI_RGB;
lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
lpDIBheader->bmiHeader.biClrUsed = 256;
// Initialize the DIB palette
for (i = 0; i < 256; i++) {
lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
}
*lpDIBHeader = lpDIBheader;
return TRUE;
}
void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
{
free(lpDIBHeader);
}

136
src/os2/icon.cpp
View File

@@ -17,8 +17,7 @@
#endif
#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/defs.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
@@ -31,120 +30,77 @@
#include "wx/icon.h"
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
#endif
/*
* Icons
*/
// ============================================================================
// implementation
// ============================================================================
wxIconRefData::wxIconRefData()
{
m_hIcon = (WXHICON) NULL ;
}
// ----------------------------------------------------------------------------
// wxIconRefData
// ----------------------------------------------------------------------------
wxIconRefData::~wxIconRefData()
void wxIconRefData::Free()
{
if ( m_hIcon )
return;
// TODO ::DestroyIcon((HICON) m_hIcon);
::DestroyIcon((HICON) m_hIcon);
}
// ----------------------------------------------------------------------------
// wxIcon
// ----------------------------------------------------------------------------
wxIcon::wxIcon()
{
}
wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
wxIcon::wxIcon(
const char WXUNUSED(bits)[]
, int WXUNUSED(nWidth)
, int WXUNUSED(nHeight)
)
{
}
wxIcon::wxIcon(const wxString& icon_file, long flags,
int desiredWidth, int desiredHeight)
wxIcon::wxIcon(
const wxString& rIconFile
, long lFlags
, int nDesiredWidth
, int nDesiredHeight
)
{
LoadFile(icon_file, flags, desiredWidth, desiredHeight);
LoadFile( rIconFile
,lFlags
,nDesiredWidth
,nDesiredHeight
);
}
wxIcon::~wxIcon()
{
}
bool wxIcon::LoadFile(const wxString& filename, long type,
int desiredWidth, int desiredHeight)
bool wxIcon::LoadFile(
const wxString& rFilename
, long lType
, int nDesiredWidth
, int nDesiredHeight
)
{
wxGDIImageHandler* pHandler = FindHandler(type);
UnRef();
m_refData = new wxIconRefData;
wxBitmapHandler *handler = FindHandler(type);
if ( handler )
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
if (pHandler)
return(pHandler->Load( this
,rFilename
,lType
,nDesiredWidth
,nDesiredHeight
));
else
return FALSE;
}
void wxIcon::SetHICON(WXHICON ico)
{
if ( !M_ICONDATA )
m_refData = new wxIconRefData;
M_ICONDATA->m_hIcon = ico;
}
bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
return FALSE;
}
bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
// TODO
/*
if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
{
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
}
else
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadIcon(wxGetInstance(), name);
}
ICONINFO info ;
if (::GetIconInfo((HICON) M_ICONHANDLERDATA->m_hIcon, &info))
{
HBITMAP ms_bitmap = info.hbmMask ;
if (ms_bitmap)
{
BITMAP bm;
::GetObject(ms_bitmap, sizeof(BITMAP), (LPSTR) &bm);
M_ICONHANDLERDATA->m_width = bm.bmWidth;
M_ICONHANDLERDATA->m_height = bm.bmHeight;
}
if (info.hbmMask)
::DeleteObject(info.hbmMask) ;
if (info.hbmColor)
::DeleteObject(info.hbmColor) ;
}
}
// Override the found values with desired values
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_width = desiredWidth;
M_ICONHANDLERDATA->m_height = desiredHeight;
}
M_ICONHANDLERDATA->m_ok = (M_ICONHANDLERDATA->m_hIcon != 0);
return M_ICONHANDLERDATA->m_ok;
}
else
*/
return FALSE;
return(FALSE);
}

133
src/os2/statbmp.cpp
View File

@@ -3,7 +3,7 @@
// Purpose: wxStaticBitmap
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 11/27/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
@@ -34,17 +34,20 @@ IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
// wxStaticBitmap
// ---------------------------------------------------------------------------
bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
bool wxStaticBitmap::Create(
wxWindow* pParent
, wxWindowID nId
, const wxGDIImage& rBitmap
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxString& rName
)
{
Init();
SetName(name);
if (parent) parent->AddChild(this);
SetName(rName);
if (pParent) parent->AddChild(this);
m_backgroundColour = parent->GetBackgroundColour() ;
m_foregroundColour = parent->GetForegroundColour() ;
@@ -52,52 +55,55 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowId = nId;
m_windowStyle = style;
m_windowStyle = lStyle;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
int nX= pos.x;
int nY = pos.y;
int nWidth = size.x;
int nHeight = size.y;
m_windowStyle = style;
m_windowStyle = lStyle;
m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));
// TODO: create static bitmap control
const wxChar* zClassname = wxT("WX_STATIC");
int nWinstyle ? SS_ICON : SS_BITMAP;
m_hWnd = (WXWHND)::WinCreateWindow( pParent->GetHWND()
,zClassname
,wxT("")
,nWinstyle | WS_VISIBLE
,0,0,0,0
,pParent->GetHWND()
,HWND_TOP
,m_windowId
,NULL
,NULL
);
wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
SetBitmap(bitmap);
SetImage(rBitmap);
// Subclass again for purposes of dialog editing mode
SubclassWin(m_hWnd);
SetFont(GetParent()->GetFont());
SetSize(x, y, width, height);
return FALSE;
SetSize(nX, nY, nWidth, nHeight);
return(FALSE);
}
bool wxStaticBitmap::ImageIsOk() const
{
if ( m_isIcon && m_image.icon )
return m_image.icon->Ok();
else if ( m_image.bitmap )
return m_image.bitmap->Ok();
else
return FALSE;
return(m_pImage ** m_pImage->Ok());
}
void wxStaticBitmap::Free()
{
if ( m_isIcon )
delete m_image.icon;
else
delete m_image.bitmap;
m_image.icon = NULL;
delete m_pImage;
m_pImage = NULL;
}
wxSize wxStaticBitmap::DoGetBestSize() const
@@ -107,22 +113,59 @@ wxSize wxStaticBitmap::DoGetBestSize() const
return wxWindow::DoGetBestSize();
}
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
void wxStaticBitmap::SetImage(
const wxGDIImage& rBitmap
)
{
Free();
m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon));
if ( m_isIcon )
m_image.icon = new wxIcon((const wxIcon&)bitmap);
m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));
if (m_bIsIcon)
m_pImage = new wxIcon((const wxIcon&)rBitmap);
else
m_image.bitmap = new wxBitmap(bitmap);
m_pImage = new wxBitmap((const wxBitmap &)rBitmap);
int x, y;
int w, h;
GetPosition(&x, &y);
GetSize(&w, &h);
int nX;
int nY;
int nW;
int nH;
// TODO: redraw bitmap
GetPosition(&nX, &nY);
GetSize(&nW, &nHh);
::WinSendMsg( GetHwnd()
,SM_SETHANDLE
,MPFROMHWND(m_pImage->GetHandle())
,NULL
);
if (ImageIsOk())
{
int nWidth = rBitmap.GetWidth();
int nHeight = rBitmap.GetHeight();
if (nWidth && nHeight)
{
nW = nWidth;
nW = nHeight;
::WinSetWindowPos( GetHwnd()
,HWND_TOP
,nX
,nY
,nWidth
,nHeight
,SWP_SIZE | SWP_MOVE | SWP_SHOW
);
}
}
RECTL vRect;
vRect.xLeft = nW;
vRect.yTop = nY;
vRect.xRight = nX + nW;
vRect.yBottom = nY + nH;
::WinInvalidateRect(GetHwndOf(GetParent()), &vRect, TRUE);
}

95
src/os2/thread.cpp
View File

@@ -596,68 +596,17 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
}
#if wxUSE_GUI
// we can't just wait for the thread to terminate because it might be
// calling some GUI functions and so it will never terminate before we
// process the Windows messages that result from these functions
ULONG ulrc;
do
{
ulrc = ::MsgWaitForMultipleObjects
(
1, // number of objects to wait for
&hThread, // the objects
FALSE, // don't wait for all objects
INFINITE, // no timeout
QS_ALLEVENTS // return as soon as there are any events
);
// need a way to finish GUI processing before killing the thread
// until then we just exit
switch ( result )
{
case 0xFFFFFFFF:
// error
wxLogSysError(_("Can not wait for thread termination"));
Kill();
return wxTHREAD_KILLED;
case WAIT_OBJECT_0:
// thread we're waiting for terminated
break;
case WAIT_OBJECT_0 + 1:
// new message arrived, process it
if ( !wxTheApp->DoMessage() )
{
// WM_QUIT received: kill the thread
Kill();
return wxTHREAD_KILLED;
}
if ( IsMain() )
{
// give the thread we're waiting for chance to exit
// from the GUI call it might have been in
if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread())
{
wxMutexGuiLeave();
}
}
break;
default:
wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
}
} while ( result != WAIT_OBJECT_0 );
#else // !wxUSE_GUI
// simply wait for the thread to terminate
//
// OTOH, even console apps create windows (in wxExecute, for WinSock
// &c), so may be use MsgWaitForMultipleObject() too here?
if ( WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0 )
{
wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
}
// can't wait for yourself to end under OS/2 so just quit
#endif // wxUSE_GUI/!wxUSE_GUI
if ( IsMain() )
@@ -670,19 +619,10 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
}
}
if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
{
wxLogLastError("GetExitCodeThread");
rc = (ExitCode)-1;
}
::DosExit(0, 0);
// probably won't get this far, but
if (IsDetached())
{
// if the thread exits normally, this is done in WinThreadStart, but in
// this case it would have been too early because
// MsgWaitForMultipleObject() would fail if the therad handle was
// closed while we were waiting on it, so we must do it here
delete this;
}
@@ -701,14 +641,19 @@ wxThreadError wxThread::Kill()
return wxTHREAD_NOT_RUNNING;
::DosKillThread(m_internal->GetHandle());
m_internal->Free();
if (IsDetached())
{
delete this;
}
return wxTHREAD_NO_ERROR;
}
void wxThread::Exit(
void* pStatus
ExitCode pStatus
)
{
m_internal->Free();
delete this;
::DosExit(EXIT_THREAD, ULONG(pStatus));
wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
@@ -730,11 +675,18 @@ unsigned int wxThread::GetPriority() const
return m_internal->GetPriority();
}
unsigned long wxThread::GetId() const
{
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
return (unsigned long)m_internal->GetId();
}
bool wxThread::IsRunning() const
{
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return m_internal->GetState() == STATE_RUNNING;
return(m_internal->GetState() == STATE_RUNNING);
}
bool wxThread::IsAlive() const
@@ -759,11 +711,6 @@ bool wxThread::TestDestroy()
return m_internal->GetState() == STATE_CANCELED;
}
wxThread::~wxThread()
{
delete m_internal;
}
// ----------------------------------------------------------------------------
// Automatic initialization for thread module
// ----------------------------------------------------------------------------