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; class WXDLLEXPORT wxLog;
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp; WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
HAB vHabmain;
// Force an exit from main loop // Force an exit from main loop
void WXDLLEXPORT wxExit(void); void WXDLLEXPORT wxExit(void);
@@ -100,7 +101,6 @@ protected:
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
private: private:
HAB m_vHab;
HMQ m_hMq; HMQ m_hMq;
QMSG m_vMsg; 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 // Purpose: wxBitmap class
// Author: David Webster // Author: David Webster
// Modified by: // Modified by:
// Created: 10/13/99 // Created: 11/28/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) David Webster // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
@@ -12,196 +12,337 @@
#ifndef _WX_BITMAP_H_ #ifndef _WX_BITMAP_H_
#define _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/gdicmn.h"
#include "wx/palette.h" #include "wx/palette.h"
// Bitmap
class WXDLLEXPORT wxDC; class WXDLLEXPORT wxDC;
class WXDLLEXPORT wxControl; class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxBitmap; class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxBitmapHandler; class WXDLLEXPORT wxBitmapHandler;
class WXDLLEXPORT wxIcon; class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxMask;
class WXDLLEXPORT wxCursor; class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxControl; 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 class WXDLLEXPORT wxMask : public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxMask)
public: public:
wxMask(); wxMask();
// Construct a mask from a bitmap and a colour indicating // Construct a mask from a bitmap and a colour indicating the transparent
// the transparent area // area
wxMask(const wxBitmap& bitmap, const wxColour& colour); wxMask( const wxBitmap& rBitmap
,const wxColour& rColour
);
// Construct a mask from a bitmap and a palette index indicating // Construct a mask from a bitmap and a palette index indicating the
// the transparent area // transparent area
wxMask(const wxBitmap& bitmap, int paletteIndex); wxMask( const wxBitmap& rBitmap
,int nPaletteIndex
);
// Construct a mask from a mono bitmap (copies the bitmap). // 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); virtual ~wxMask();
bool Create(const wxBitmap& bitmap, int paletteIndex);
bool Create(const wxBitmap& bitmap); bool Create( const wxBitmap& bitmap
,const wxColour& rColour
);
bool Create( const wxBitmap& rBitmap
,int nPaletteIndex
);
bool Create(const wxBitmap& rBitmap);
// Implementation // Implementation
inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; } WXHBITMAP GetMaskBitmap() const
inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; } { return m_hMaskBitmap; }
void SetMaskBitmap(WXHBITMAP hBmp)
{ m_hMaskBitmap = hBmp; }
protected: 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: public:
wxBitmapRefData(); inline wxBitmapHandler()
~wxBitmapRefData(); { m_lType = wxBITMAP_TYPE_INVALID; }
public: inline wxBitmapHandler( const wxString& rName
int m_width; ,const wxString& rExt
int m_height; ,long lType
int m_depth; )
bool m_ok; : wxGDIImageHandler( rName
int m_numColors; ,rExt
wxPalette m_bitmapPalette; ,lType)
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
{ {
}
// 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) 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 #endif
// _WX_BITMAP_H_ // _WX_BITMAP_H_

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

@@ -12,91 +12,89 @@
#ifndef _WX_ICON_H_ #ifndef _WX_ICON_H_
#define _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" #include "wx/bitmap.h"
class WXDLLEXPORT wxIconRefData: public wxBitmapRefData #define wxIconRefDataBase wxBitmapRefData
{ #define wxIconBase wxBitmap
friend class WXDLLEXPORT wxBitmap; #else
friend class WXDLLEXPORT wxIcon; #include "wx/os2/gdiimage.h"
public:
wxIconRefData();
~wxIconRefData();
#define wxIconRefDataBase wxGDIImageRefData
#define wxIconBase wxGDIImage
#endif
class WXDLLEXPORT wxIconRefData: public wxIconRefDataBase
{
public:
wxIconRefData() { };
virtual ~wxIconRefData() { Free(); m_hIcon = NULL; }
virtual void Free();
public: public:
WXHICON m_hIcon; WXHICON m_hIcon;
}; };
#define M_ICONDATA ((wxIconRefData *)m_refData) // ---------------------------------------------------------------------------
#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData())
// Icon // Icon
class WXDLLEXPORT wxIcon: public wxBitmap // ---------------------------------------------------------------------------
{
DECLARE_DYNAMIC_CLASS(wxIcon)
class WXDLLEXPORT wxIcon: public wxIconBase
{
public: public:
wxIcon(); wxIcon();
// Copy constructors // Copy constructors
inline wxIcon(const wxIcon& icon) { Ref(icon); } inline wxIcon(const wxIcon& icon) { Ref(icon); }
wxIcon(const char bits[], int width, int height); wxIcon( const char bits[]
wxIcon(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE, ,int nWidth
int desiredWidth = -1, int desiredHeight = -1); ,int nHeight
);
wxIcon( const wxString& rName
,long lFlags = wxBITMAP_TYPE_ICO_RESOURCE
,int nDesiredWidth = -1
,int nDesiredHeight = -1
);
~wxIcon(); ~wxIcon();
bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE, bool LoadFile( const wxString& rName
int desiredWidth = -1, int desiredHeight = -1); ,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 wxIcon& operator = (const wxIcon& rIcon)
inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; } { if (*this == rIcon) Ref(rIcon); return *this; }
inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; } 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); wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
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: private:
// supress virtual function hiding warning DECLARE_DYNAMIC_CLASS(wxIcon)
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);
}; };
#endif #endif
// _WX_ICON_H_ // _WX_ICON_H_

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

@@ -16,6 +16,9 @@
// global settings // 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 this to 0 when building wxBase library
#define wxUSE_GUI 1 #define wxUSE_GUI 1

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

@@ -16,6 +16,9 @@
// global settings // 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 this to 0 when building wxBase library
#define wxUSE_GUI 1 #define wxUSE_GUI 1

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

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

5
src/os2/app.cpp
View File

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

806
src/os2/bitmap.cpp
View File

@@ -27,6 +27,9 @@
#include "wx/os2/private.h" #include "wx/os2/private.h"
#include "wx/log.h" #include "wx/log.h"
//#include "wx/msw/dib.h"
#include "wx/image.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// macros // macros
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -34,76 +37,104 @@
#if !USE_SHARED_LIBRARIES #if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
#endif #endif
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxBitmapRefData
// ----------------------------------------------------------------------------
wxBitmapRefData::wxBitmapRefData() wxBitmapRefData::wxBitmapRefData()
{ {
m_ok = FALSE; m_nQuality = 0;
m_width = 0; m_pSelectedInto = NULL;
m_height = 0; m_nNumColors = 0;
m_depth = 0; m_pBitmapMask = NULL;
m_quality = 0;
m_hBitmap = 0 ;
m_selectedInto = NULL;
m_numColors = 0;
m_bitmapMask = NULL;
} }
wxBitmapRefData::~wxBitmapRefData() void wxBitmapRefData::Free()
{ {
if (m_selectedInto) wxASSERT_MSG( !m_pSelectedInto,
{ wxT("deleting bitmap still selected into wxMemoryDC") );
wxChar buf[200];
wxSprintf(buf, wxT("Bitmap was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) m_selectedInto);
wxFatalError(buf);
}
if (m_hBitmap) if (m_hBitmap)
{ {
// TODO: DeleteObject((HBITMAP) m_hBitmap); if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
}
m_hBitmap = 0 ;
if (m_bitmapMask)
delete m_bitmapMask;
m_bitmapMask = NULL;
}
wxList wxBitmap::sm_handlers;
wxBitmap::wxBitmap()
{ {
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) if (wxTheBitmapList)
wxTheBitmapList->AddBitmap(this); wxTheBitmapList->AddBitmap(this);
} }
wxBitmap::wxBitmap(const wxBitmap& bitmap) bool wxBitmap::CopyFromIconOrCursor(
const wxGDIImage& rIcon
)
{ {
// TODO: wxBitmapRefData* pRefData = new wxBitmapRefData;
/*
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());
::DeleteDC(hdc); m_refData = pRefData;
SetHBITMAP((WXHBITMAP)hbitmap); refData->m_width = rIcon.GetWidth();
} refData->m_height = rIcon.GetHeight();
else refData->m_depth = wxDisplayDepth();
{
Ref(bitmap); 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 ) bool wxBitmap::CopyFromCursor(
wxTheBitmapList->AddBitmap(this); 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() wxBitmap::~wxBitmap()
@@ -112,265 +143,299 @@ wxBitmap::~wxBitmap()
wxTheBitmapList->DeleteObject(this); wxTheBitmapList->DeleteObject(this);
} }
bool wxBitmap::FreeResource(bool WXUNUSED(force)) wxBitmap::wxBitmap(
const char zBits[]
, int nTheWidth
, int nTheHeight
, int nNoBits
)
{ {
if ( !M_BITMAPDATA ) Init();
return FALSE;
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]; wxLogLastError("GpiCreatePS Failure");
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;
} }
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; wxLogLastError("CreateBitmap");
}
M_BITMAPDATA->m_width = the_width ; SetHBITMAP((WXHBITMAP)hbmp);
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);
} }
// Create from XPM data // 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 ) (void)Create( nW
wxTheBitmapList->AddBitmap(this); ,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 ) (void)Create( pData
wxTheBitmapList->AddBitmap(this); ,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 ) LoadFile( rFilename
wxTheBitmapList->AddBitmap(this); ,(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(); UnRef();
m_refData = new wxBitmapRefData; m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_width = w; GetBitmapData()->m_width = nW;
M_BITMAPDATA->m_height = h; GetBitmapData()->m_height = nH;
M_BITMAPDATA->m_depth = d; 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) bool wxBitmap::LoadFile(const wxString& filename, long type)
{ {
UnRef(); UnRef();
wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
if ( handler )
{
m_refData = new wxBitmapRefData; 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); 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) bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
{ {
UnRef(); UnRef();
m_refData = new wxBitmapRefData; wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
wxBitmapHandler *handler = FindHandler(type); if ( !handler )
{
if ( handler == NULL ) { wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
wxLogWarning("no bitmap handler for type %d defined.", type); "type %d defined."), type);
return FALSE; return FALSE;
} }
m_refData = new wxBitmapRefData;
return handler->Create(this, data, type, width, height, depth); return handler->Create(this, data, type, width, height, depth);
} }
bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette)
{ {
wxBitmapHandler *handler = FindHandler(type); wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
if ( handler == NULL ) {
wxLogWarning("no bitmap handler for type %d defined.", type);
return FALSE;
}
if ( handler )
{
return handler->SaveFile(this, filename, type, palette); return handler->SaveFile(this, filename, type, palette);
} }
else
void wxBitmap::SetWidth(int w)
{ {
if (!M_BITMAPDATA) // FIXME what about palette? shouldn't we use it?
m_refData = new wxBitmapRefData; wxImage image( *this );
if (!image.Ok())
return FALSE;
M_BITMAPDATA->m_width = w; return image.SaveFile( filename, type );
}
} }
void wxBitmap::SetHeight(int h) // ----------------------------------------------------------------------------
{ // wxBitmap accessors
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;
}
void wxBitmap::SetQuality(int q) void wxBitmap::SetQuality(int q)
{ {
if (!M_BITMAPDATA) EnsureHasData();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_quality = q; GetBitmapData()->m_quality = q;
} }
#if WXWIN_COMPATIBILITY_2
void wxBitmap::SetOk(bool isOk) void wxBitmap::SetOk(bool isOk)
{ {
if (!M_BITMAPDATA) EnsureHasData();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_ok = isOk; GetBitmapData()->m_ok = isOk;
} }
#endif // WXWIN_COMPATIBILITY_2
void wxBitmap::SetPalette(const wxPalette& palette) void wxBitmap::SetPalette(const wxPalette& palette)
{ {
if (!M_BITMAPDATA) EnsureHasData();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_bitmapPalette = palette ; GetBitmapData()->m_bitmapPalette = palette;
} }
void wxBitmap::SetMask(wxMask *mask) void wxBitmap::SetMask(wxMask *mask)
{ {
if (!M_BITMAPDATA) EnsureHasData();
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_bitmapMask = mask ; GetBitmapData()->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;
} }
// Creates a bitmap that matches the device context, from // 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> // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
{ {
wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
// TODO:
/*
wxMemoryDC memDC; wxMemoryDC memDC;
wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
HPALETTE hPal = (HPALETTE) NULL; HPALETTE hPal = (HPALETTE) NULL;
LPBITMAPINFO lpDib; LPBITMAPINFO lpDib;
void *lpBits = (void*) NULL; void *lpBits = (void*) NULL;
if( GetPalette() && GetPalette()->Ok() )
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) )
{ {
tmpBitmap.SetPalette(* this->GetPalette()); tmpBitmap.SetPalette(*GetPalette());
memDC.SelectObject(tmpBitmap); memDC.SelectObject(tmpBitmap);
memDC.SetPalette(* this->GetPalette()); memDC.SetPalette(*GetPalette());
hPal = (HPALETTE) this->GetPalette()->GetHPALETTE(); hPal = (HPALETTE)GetPalette()->GetHPALETTE();
} }
else else
{ {
@@ -413,26 +467,32 @@ wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
memDC.SetPalette( palette ); memDC.SetPalette( palette );
} }
// set the height negative because in a DIB the order of the lines is reversed // set the height negative because in a DIB the order of the lines is
createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib); // reversed
if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
{
return wxNullBitmap;
}
lpBits = malloc(lpDib->bmiHeader.biSizeImage); 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(), ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS); GetWidth(), GetHeight(),
0, 0, 0, GetHeight(),
lpBits, lpDib, DIB_RGB_COLORS);
free(lpBits); free(lpBits);
freeDIB(lpDib); wxFreeDIB(lpDib);
*/
return (tmpBitmap); return tmpBitmap;
} }
/* // ----------------------------------------------------------------------------
* wxMask // wxMask
*/ // ----------------------------------------------------------------------------
wxMask::wxMask() wxMask::wxMask()
{ {
@@ -464,21 +524,57 @@ wxMask::wxMask(const wxBitmap& bitmap)
wxMask::~wxMask() wxMask::~wxMask()
{ {
// TODO: delete mask bitmap if ( m_maskBitmap )
::DeleteObject((HBITMAP) m_maskBitmap);
} }
// Create a mask from a mono bitmap (copies the bitmap). // Create a mask from a mono bitmap (copies the bitmap).
bool wxMask::Create(const wxBitmap& bitmap) bool wxMask::Create(const wxBitmap& bitmap)
{ {
// TODO if ( m_maskBitmap )
{
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
}
if (!bitmap.Ok() || bitmap.GetDepth() != 1)
{
return FALSE; 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 // Create a mask from a bitmap and a palette index indicating
// the transparent area // the transparent area
bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex) 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; return FALSE;
} }
@@ -486,76 +582,164 @@ bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
// the transparent area // the transparent area
bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour) bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
{ {
// TODO if ( m_maskBitmap )
return FALSE; {
::DeleteObject((HBITMAP) m_maskBitmap);
m_maskBitmap = 0;
} }
if (!bitmap.Ok())
/*
* wxBitmapHandler
*/
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
{ {
return FALSE; return FALSE;
} }
bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type, // scan the bitmap for the transparent colour and set
int desiredWidth, int desiredHeight) // 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; 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; return FALSE;
} }
/* bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
* Standard handlers const wxString& WXUNUSED(name),
*/ int WXUNUSED(type),
const wxPalette *WXUNUSED(palette))
/* TODO: bitmap handlers, a bit like this:
class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler
{ {
DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) return FALSE;
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;
}
} }
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. unsigned long i, headerSize;
AddHandler(new wxBMPResourceHandler); LPBITMAPINFO lpDIBheader = NULL;
AddHandler(new wxBMPFileHandler); LPPALETTEENTRY lpPe = NULL;
AddHandler(new wxXPMFileHandler);
AddHandler(new wxXPMDataHandler);
AddHandler(new wxICOResourceHandler); // Allocate space for a DIB header
AddHandler(new wxICOFileHandler); 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 #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include <stdio.h> #include "wx/defs.h"
#include "wx/setup.h"
#include "wx/list.h" #include "wx/list.h"
#include "wx/utils.h" #include "wx/utils.h"
#include "wx/app.h" #include "wx/app.h"
@@ -31,120 +30,77 @@
#include "wx/icon.h" #include "wx/icon.h"
#if !USE_SHARED_LIBRARIES #if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap) IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif #endif
/* // ============================================================================
* Icons // implementation
*/ // ============================================================================
wxIconRefData::wxIconRefData() // ----------------------------------------------------------------------------
{ // wxIconRefData
m_hIcon = (WXHICON) NULL ; // ----------------------------------------------------------------------------
}
wxIconRefData::~wxIconRefData() void wxIconRefData::Free()
{ {
if ( m_hIcon ) if ( m_hIcon )
return; ::DestroyIcon((HICON) m_hIcon);
// TODO ::DestroyIcon((HICON) m_hIcon);
} }
// ----------------------------------------------------------------------------
// wxIcon
// ----------------------------------------------------------------------------
wxIcon::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, wxIcon::wxIcon(
int desiredWidth, int desiredHeight) const wxString& rIconFile
, long lFlags
, int nDesiredWidth
, int nDesiredHeight
)
{ {
LoadFile(icon_file, flags, desiredWidth, desiredHeight); LoadFile( rIconFile
,lFlags
,nDesiredWidth
,nDesiredHeight
);
} }
wxIcon::~wxIcon() wxIcon::~wxIcon()
{ {
} }
bool wxIcon::LoadFile(const wxString& filename, long type, bool wxIcon::LoadFile(
int desiredWidth, int desiredHeight) const wxString& rFilename
, long lType
, int nDesiredWidth
, int nDesiredHeight
)
{ {
wxGDIImageHandler* pHandler = FindHandler(type);
UnRef(); UnRef();
m_refData = new wxIconRefData; m_refData = new wxIconRefData;
wxBitmapHandler *handler = FindHandler(type); if (pHandler)
return(pHandler->Load( this
if ( handler ) ,rFilename
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); ,lType
,nDesiredWidth
,nDesiredHeight
));
else else
return FALSE; 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;
} }

133
src/os2/statbmp.cpp
View File

@@ -3,7 +3,7 @@
// Purpose: wxStaticBitmap // Purpose: wxStaticBitmap
// Author: David Webster // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 11/27/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) David Webster // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
@@ -34,17 +34,20 @@ IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
// wxStaticBitmap // wxStaticBitmap
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id, bool wxStaticBitmap::Create(
const wxBitmap& bitmap, wxWindow* pParent
const wxPoint& pos, , wxWindowID nId
const wxSize& size, , const wxGDIImage& rBitmap
long style, , const wxPoint& rPos
const wxString& name) , const wxSize& rSize
, long lStyle
, const wxString& rName
)
{ {
Init(); Init();
SetName(name); SetName(rName);
if (parent) parent->AddChild(this); if (pParent) parent->AddChild(this);
m_backgroundColour = parent->GetBackgroundColour() ; m_backgroundColour = parent->GetBackgroundColour() ;
m_foregroundColour = parent->GetForegroundColour() ; m_foregroundColour = parent->GetForegroundColour() ;
@@ -52,52 +55,55 @@ bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
if ( id == -1 ) if ( id == -1 )
m_windowId = (int)NewControlId(); m_windowId = (int)NewControlId();
else else
m_windowId = id; m_windowId = nId;
m_windowStyle = style; m_windowStyle = lStyle;
int x = pos.x; int nX= pos.x;
int y = pos.y; int nY = pos.y;
int width = size.x; int nWidth = size.x;
int height = size.y; 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 // 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") ); wxCHECK_MSG( m_hWnd, FALSE, wxT("Failed to create static bitmap") );
SetBitmap(bitmap); SetImage(rBitmap);
// Subclass again for purposes of dialog editing mode // Subclass again for purposes of dialog editing mode
SubclassWin(m_hWnd); SubclassWin(m_hWnd);
SetFont(GetParent()->GetFont()); SetFont(GetParent()->GetFont());
SetSize(nX, nY, nWidth, nHeight);
SetSize(x, y, width, height); return(FALSE);
return FALSE;
} }
bool wxStaticBitmap::ImageIsOk() const bool wxStaticBitmap::ImageIsOk() const
{ {
if ( m_isIcon && m_image.icon ) return(m_pImage ** m_pImage->Ok());
return m_image.icon->Ok();
else if ( m_image.bitmap )
return m_image.bitmap->Ok();
else
return FALSE;
} }
void wxStaticBitmap::Free() void wxStaticBitmap::Free()
{ {
if ( m_isIcon ) delete m_pImage;
delete m_image.icon; m_pImage = NULL;
else
delete m_image.bitmap;
m_image.icon = NULL;
} }
wxSize wxStaticBitmap::DoGetBestSize() const wxSize wxStaticBitmap::DoGetBestSize() const
@@ -107,22 +113,59 @@ wxSize wxStaticBitmap::DoGetBestSize() const
return wxWindow::DoGetBestSize(); return wxWindow::DoGetBestSize();
} }
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap) void wxStaticBitmap::SetImage(
const wxGDIImage& rBitmap
)
{ {
Free(); Free();
m_isIcon = bitmap.IsKindOf(CLASSINFO(wxIcon)); m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));
if ( m_isIcon ) if (m_bIsIcon)
m_image.icon = new wxIcon((const wxIcon&)bitmap); m_pImage = new wxIcon((const wxIcon&)rBitmap);
else else
m_image.bitmap = new wxBitmap(bitmap); m_pImage = new wxBitmap((const wxBitmap &)rBitmap);
int x, y; int nX;
int w, h; int nY;
GetPosition(&x, &y); int nW;
GetSize(&w, &h); 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 #if wxUSE_GUI
// we can't just wait for the thread to terminate because it might be // need a way to finish GUI processing before killing the thread
// calling some GUI functions and so it will never terminate before we // until then we just exit
// 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
);
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()) if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread())
{ {
wxMutexGuiLeave(); wxMutexGuiLeave();
} }
}
break;
default:
wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
}
} while ( result != WAIT_OBJECT_0 );
#else // !wxUSE_GUI #else // !wxUSE_GUI
// simply wait for the thread to terminate
// // can't wait for yourself to end under OS/2 so just quit
// 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"));
}
#endif // wxUSE_GUI/!wxUSE_GUI #endif // wxUSE_GUI/!wxUSE_GUI
if ( IsMain() ) if ( IsMain() )
@@ -670,19 +619,10 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
} }
} }
if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) ) ::DosExit(0, 0);
{ // probably won't get this far, but
wxLogLastError("GetExitCodeThread");
rc = (ExitCode)-1;
}
if (IsDetached()) 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; delete this;
} }
@@ -701,14 +641,19 @@ wxThreadError wxThread::Kill()
return wxTHREAD_NOT_RUNNING; return wxTHREAD_NOT_RUNNING;
::DosKillThread(m_internal->GetHandle()); ::DosKillThread(m_internal->GetHandle());
m_internal->Free();
if (IsDetached())
{
delete this; delete this;
}
return wxTHREAD_NO_ERROR; return wxTHREAD_NO_ERROR;
} }
void wxThread::Exit( void wxThread::Exit(
void* pStatus ExitCode pStatus
) )
{ {
m_internal->Free();
delete this; delete this;
::DosExit(EXIT_THREAD, ULONG(pStatus)); ::DosExit(EXIT_THREAD, ULONG(pStatus));
wxFAIL_MSG(wxT("Couldn't return from DosExit()!")); wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
@@ -730,11 +675,18 @@ unsigned int wxThread::GetPriority() const
return m_internal->GetPriority(); 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 bool wxThread::IsRunning() const
{ {
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return m_internal->GetState() == STATE_RUNNING; return(m_internal->GetState() == STATE_RUNNING);
} }
bool wxThread::IsAlive() const bool wxThread::IsAlive() const
@@ -759,11 +711,6 @@ bool wxThread::TestDestroy()
return m_internal->GetState() == STATE_CANCELED; return m_internal->GetState() == STATE_CANCELED;
} }
wxThread::~wxThread()
{
delete m_internal;
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Automatic initialization for thread module // Automatic initialization for thread module
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------