From 3b9e3455225b670d30ee0fb67f8821ada9640f6d Mon Sep 17 00:00:00 2001 From: David Webster Date: Fri, 3 Dec 1999 05:03:55 +0000 Subject: [PATCH] bitmap and image updates git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4800 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/os2/app.h | 2 +- include/wx/os2/bitmap.h | 449 +++++++++++++-------- include/wx/os2/icon.h | 140 ++++--- include/wx/os2/setup.h | 3 + include/wx/os2/setup0.h | 5 +- include/wx/os2/statbmp.h | 100 ++--- src/os2/app.cpp | 15 +- src/os2/bitmap.cpp | 822 ++++++++++++++++++++++++--------------- src/os2/icon.cpp | 152 +++----- src/os2/statbmp.cpp | 139 ++++--- src/os2/thread.cpp | 107 ++--- 11 files changed, 1107 insertions(+), 827 deletions(-) diff --git a/include/wx/os2/app.h b/include/wx/os2/app.h index 69974b6c55..effb025e8b 100644 --- a/include/wx/os2/app.h +++ b/include/wx/os2/app.h @@ -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; }; diff --git a/include/wx/os2/bitmap.h b/include/wx/os2/bitmap.h index 8ed76d060f..5ad96f1a55 100644 --- a/include/wx/os2/bitmap.h +++ b/include/wx/os2/bitmap.h @@ -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. -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 palette index indicating - // the transparent area - wxMask(const wxBitmap& bitmap, int paletteIndex); - - // Construct a mask from a mono bitmap (copies the bitmap). - wxMask(const wxBitmap& bitmap); - - ~wxMask(); +// ---------------------------------------------------------------------------- +// Bitmap data +// +// NB: this class is private, but declared here to make it possible inline +// wxBitmap functions accessing it +// ---------------------------------------------------------------------------- - bool Create(const wxBitmap& bitmap, const wxColour& colour); - bool Create(const wxBitmap& bitmap, int paletteIndex); - bool Create(const wxBitmap& bitmap); - - // Implementation - inline WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; } - inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; } -protected: - WXHBITMAP m_maskBitmap; -}; - -class WXDLLEXPORT wxBitmapRefData: public wxGDIRefData +class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData { - friend class WXDLLEXPORT wxBitmap; - friend class WXDLLEXPORT wxIcon; - friend class WXDLLEXPORT wxCursor; public: wxBitmapRefData(); - ~wxBitmapRefData(); + virtual ~wxBitmapRefData() { Free(); } + + virtual void Free(); 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 -}; + int m_nNumColors; + wxPalette m_vBitmapPalette; + int m_nQuality; -#define M_BITMAPDATA ((wxBitmapRefData *)m_refData) + // OS2-specific + // ------------ -class WXDLLEXPORT wxBitmapHandler: public wxObject -{ - 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; + wxDC* m_pSelectedInto; + HPS m_hPresentationSpace; + + // optional mask for transparent drawing + wxMask* m_pBitmapMask; }; -#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData()) +// ---------------------------------------------------------------------------- +// wxBitmap: a mono or colour bitmap +// ---------------------------------------------------------------------------- -class WXDLLEXPORT wxBitmap: public wxGDIObject +class WXDLLEXPORT wxBitmap : public wxGDIImage { - 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); + // 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 - // 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); +#if WXWIN_COMPATIBILITY + inline wxPalette* GetColourMap() const + { return GetPalette(); } - // New constructor for generalised creation from data - wxBitmap(void *data, long type, int width, int height, int depth = 1); + inline void SetColourMap(wxPalette* pCmap) + { SetPalette(*pCmap); }; - // If depth is omitted, will create a bitmap compatible with the display - wxBitmap(int width, int height, int depth = -1); - ~wxBitmap(); +#endif // WXWIN_COMPATIBILITY - 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); + // 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 + // + wxBitmap GetBitmapForDC(wxDC& rDc) const; - 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); +protected: + // common part of all ctors + void Init(); -#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 virtual wxGDIImageRefData* CreateData() const + { return new wxBitmapRefData; } - inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); } - void SetMask(wxMask *mask) ; +private: + bool CopyFromIconOrCursor(const wxGDIImage& rIcon); - inline wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; } + DECLARE_DYNAMIC_CLASS(wxBitmap) +}; - inline bool operator == (const wxBitmap& bitmap) { return m_refData == bitmap.m_refData; } - inline bool operator != (const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; } +// ---------------------------------------------------------------------------- +// wxMask: a mono bitmap used for drawing bitmaps transparently. +// ---------------------------------------------------------------------------- - // 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); +class WXDLLEXPORT wxMask : public wxObject +{ +public: + wxMask(); + + // 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& rBitmap + ,int nPaletteIndex + ); + + // Construct a mask from a mono bitmap (copies the bitmap). + wxMask(const wxBitmap& rBitmap); + + // construct a mask from the givne bitmap handle + wxMask(WXHBITMAP hBmp) + { m_hMaskBitmap = hBmp; } + + virtual ~wxMask(); + + bool Create( const wxBitmap& bitmap + ,const wxColour& rColour + ); + bool Create( const wxBitmap& rBitmap + ,int nPaletteIndex + ); + bool Create(const wxBitmap& rBitmap); + + // Implementation + WXHBITMAP GetMaskBitmap() const + { return m_hMaskBitmap; } + void SetMaskBitmap(WXHBITMAP hBmp) + { m_hMaskBitmap = hBmp; } - static void InitStandardHandlers(); - static void CleanUpHandlers(); protected: - static wxList sm_handlers; + WXHBITMAP m_hMaskBitmap; + DECLARE_DYNAMIC_CLASS(wxMask) +}; + +// ---------------------------------------------------------------------------- +// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file +// ---------------------------------------------------------------------------- - // Implementation +class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler +{ 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 - wxBitmap GetBitmapForDC(wxDC& dc) const; + inline wxBitmapHandler() + { m_lType = wxBITMAP_TYPE_INVALID; } + + 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) }; + #endif // _WX_BITMAP_H_ diff --git a/include/wx/os2/icon.h b/include/wx/os2/icon.h index 07a1f4fb55..c6b46a110f 100644 --- a/include/wx/os2/icon.h +++ b/include/wx/os2/icon.h @@ -12,91 +12,89 @@ #ifndef _WX_ICON_H_ #define _WX_ICON_H_ -#include "wx/bitmap.h" +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + +// compatible (even if incorrect) behaviour by default: derive wxIcon from +// wxBitmap +#ifndef wxICON_IS_BITMAP + #define wxICON_IS_BITMAP 1 +#endif -class WXDLLEXPORT wxIconRefData: public wxBitmapRefData -{ - friend class WXDLLEXPORT wxBitmap; - friend class WXDLLEXPORT wxIcon; -public: - wxIconRefData(); - ~wxIconRefData(); +#if wxICON_IS_BITMAP + #include "wx/bitmap.h" -public: - WXHICON m_hIcon; -}; + #define wxIconRefDataBase wxBitmapRefData + #define wxIconBase wxBitmap +#else + #include "wx/os2/gdiimage.h" -#define M_ICONDATA ((wxIconRefData *)m_refData) -#define M_ICONHANDLERDATA ((wxIconRefData *)bitmap->GetRefData()) + #define wxIconRefDataBase wxGDIImageRefData + #define wxIconBase wxGDIImage +#endif -// Icon -class WXDLLEXPORT wxIcon: public wxBitmap +class WXDLLEXPORT wxIconRefData: public wxIconRefDataBase { - DECLARE_DYNAMIC_CLASS(wxIcon) - 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(); - - bool LoadFile(const wxString& name, long flags = wxBITMAP_TYPE_ICO_RESOURCE, - int desiredWidth = -1, int desiredHeight = -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; } + wxIconRefData() { }; + virtual ~wxIconRefData() { Free(); m_hIcon = NULL; } - void SetHICON(WXHICON ico); - inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); } - - 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) + virtual void Free(); 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); + WXHICON m_hIcon; }; -class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler +// --------------------------------------------------------------------------- +// Icon +// --------------------------------------------------------------------------- + +class WXDLLEXPORT wxIcon: public wxIconBase { - 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); + wxIcon(); + + // Copy constructors + inline wxIcon(const wxIcon& icon) { Ref(icon); } + + 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& rName + ,long lFlags = wxBITMAP_TYPE_ICO_RESOURCE + ,int nDesiredWidth = -1 + ,int nDesiredHeight = -1 + ); + + 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; } + + 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; + } +private: + DECLARE_DYNAMIC_CLASS(wxIcon) }; #endif // _WX_ICON_H_ - diff --git a/include/wx/os2/setup.h b/include/wx/os2/setup.h index 4cadb335d5..5042e1dcbc 100644 --- a/include/wx/os2/setup.h +++ b/include/wx/os2/setup.h @@ -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 diff --git a/include/wx/os2/setup0.h b/include/wx/os2/setup0.h index f7afa63a33..36254e5f5c 100644 --- a/include/wx/os2/setup0.h +++ b/include/wx/os2/setup0.h @@ -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 @@ -163,7 +166,7 @@ // Some databases/ODBC drivers only allow forward scrolling cursors. // Unless you specifically want to use backward scrolling // cursors, and you know that all of the databases/ODBC drivers - // that you will use these odbc classes with allow backward + // that you will use these odbc classes with allow backward // scrolling cursors, this setting should remain set to 1 // for maximum database/driver compatibilty diff --git a/include/wx/os2/statbmp.h b/include/wx/os2/statbmp.h index 90721844b8..01ad8f183a 100644 --- a/include/wx/os2/statbmp.h +++ b/include/wx/os2/statbmp.h @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// // 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 -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_STATBMP_H_ @@ -17,61 +17,65 @@ #endif #include "wx/control.h" +#include "wx/icon.h" WXDLLEXPORT_DATA(extern const char*) wxStaticBitmapNameStr; class WXDLLEXPORT wxStaticBitmap: public wxControl { - DECLARE_DYNAMIC_CLASS(wxStaticBitmap) + DECLARE_DYNAMIC_CLASS(wxStaticBitmap) public: - inline wxStaticBitmap() { } - - inline wxStaticBitmap(wxWindow *parent, wxWindowID id, - const wxBitmap& label, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = 0, - const wxString& name = wxStaticBitmapNameStr) - { - Create(parent, id, label, pos, size, style, name); - } - - bool Create(wxWindow *parent, wxWindowID id, - const wxBitmap& label, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = 0, - const wxString& name = wxStaticBitmapNameStr); - - virtual void SetIcon(const wxIcon& icon) { SetBitmap(icon); } - virtual void SetBitmap(const wxBitmap& bitmap); - - // 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; } - const wxBitmap& GetBitmap() const - { wxASSERT( !m_isIcon ); return *m_image.bitmap; } - - // overriden base class virtuals - virtual bool AcceptsFocus() const { return FALSE; } + inline wxStaticBitmap() { Init(); } + + 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(pParent, nId, rLabel, rPos, rSize, lStyle, rName); + } + + 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& 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_bIsIcon ); return *(wxIcon *)m_pImage; } + const wxBitmap& GetBitmap() const + { 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; } - void Free(); + virtual wxSize DoGetBestSize() const; + + void Init() { m_bIsIcon = TRUE; m_pImage = NULL; } + void Free(); - // TRUE if icon/bitmap is valid - bool ImageIsOk() const; + // 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 diff --git a/src/os2/app.cpp b/src/os2/app.cpp index f4f9a25d9c..9abb82c4ba 100644 --- a/src/os2/app.cpp +++ b/src/os2/app.cpp @@ -185,13 +185,14 @@ bool wxApp::RegisterWindowClasses( HAB vHab ) { - - if (!::WinRegisterClass( vHab - ,wxFrameClassName - ,(PFNWP)wxWndProc - ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME - ,0 - )) + APIRET rc; + + if ((rc = ::WinRegisterClass( vHab + ,wxFrameClassName + ,(PFNWP)wxWndProc + ,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME + ,0 + )) != 0) { wxLogLastError("RegisterClass(frame)"); diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp index 93ea059994..872a468db5 100644 --- a/src/os2/bitmap.cpp +++ b/src/os2/bitmap.cpp @@ -27,6 +27,9 @@ #include "wx/os2/private.h" #include "wx/log.h" +//#include "wx/msw/dib.h" +#include "wx/image.h" + // ---------------------------------------------------------------------------- // macros // ---------------------------------------------------------------------------- @@ -34,343 +37,405 @@ #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); - } - if (m_hBitmap) - { -// TODO: DeleteObject((HBITMAP) m_hBitmap); - } - m_hBitmap = 0 ; + wxASSERT_MSG( !m_pSelectedInto, + wxT("deleting bitmap still selected into wxMemoryDC") ); - if (m_bitmapMask) - delete m_bitmapMask; - m_bitmapMask = NULL; + if (m_hBitmap) + { + if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) ) + { + wxLogLastError("GpiDeleteBitmap(hbitmap)"); + } + } + + delete m_pBitmapMask; + m_pBitmapMask = NULL; } -wxList wxBitmap::sm_handlers; +// ---------------------------------------------------------------------------- +// wxBitmap creation +// ---------------------------------------------------------------------------- -wxBitmap::wxBitmap() +// this function should be called from all wxBitmap ctors +void wxBitmap::Init() { - m_refData = NULL; + // m_refData = NULL; done in the base class ctor - if ( wxTheBitmapList ) + if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this); } -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(); - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -*/ -} + refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle(); + // no mask??? + refData->m_bitmapMask = new wxMask(); -wxBitmap::~wxBitmap() -{ - if (wxTheBitmapList) - wxTheBitmapList->DeleteObject(this); +#if WXWIN_COMPATIBILITY_2 + refData->m_ok = TRUE; +#endif // WXWIN_COMPATIBILITY_2 + + return(TRUE); } -bool wxBitmap::FreeResource(bool WXUNUSED(force)) +bool wxBitmap::CopyFromCursor( + const wxCursor& rCursor +) { - if ( !M_BITMAPDATA ) - return FALSE; - - if (M_BITMAPDATA->m_selectedInto) - { - 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 ; -*/ + UnRef(); - return TRUE; + if (!rCursor.Ok()) + return(FALSE); + return CopyFromIconOrCursor(wxGDIImage)rCursor); } - -wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits) +bool wxBitmap::CopyFromIcon( + const wxIcon& rIcon +) { - m_refData = new wxBitmapRefData; + UnRef(); - M_BITMAPDATA->m_width = the_width ; - M_BITMAPDATA->m_height = the_height ; - M_BITMAPDATA->m_depth = no_bits ; - M_BITMAPDATA->m_numColors = 0; + if (!rIcon.Ok()) + return(FALSE); - /* TODO: create the bitmap from data */ +#if WXWIN_COMPATIBILITY_2 + refData->m_ok = TRUE; +#endif // WXWIN_COMPATIBILITY_2 - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); + return CopyFromIconOrCursor(icon); } -// Create from XPM data -wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem)) +wxBitmap::~wxBitmap() { - (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); + if (wxTheBitmapList) + wxTheBitmapList->DeleteObject(this); } -wxBitmap::wxBitmap(int w, int h, int d) -{ - (void)Create(w, h, d); +wxBitmap::wxBitmap( + const char zBits[] +, int nTheWidth +, int nTheHeight +, int nNoBits +) +{ + Init(); + + 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) + { + wxLogLastError("GpiCreatePS Failure"); + } - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} + m_refData = pRefData; -wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) -{ - (void) Create(data, type, width, height, depth); + refData->m_width = nTheWidth; + refData->m_height = nTheHeight; + refData->m_depth = nNoBits; + refData->m_numColors = 0; + refData->m_selectedInto = NULL; - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); + HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo); + if ( !hbmp ) + { + wxLogLastError("CreateBitmap"); + } + SetHBITMAP((WXHBITMAP)hbmp); } -wxBitmap::wxBitmap(const wxString& filename, long type) -{ - LoadFile(filename, (int)type); +// Create from XPM data +wxBitmap::wxBitmap( + char** ppData +, wxControl* WXUNUSED(pAnItem)) +{ + Init(); + +F (void)Create( (void *)ppData + ,wxBITMAP_TYPE_XPM_DATA + ,0 + ,0 + ,0 + ); +} + +wxBitmap::wxBitmap( + int nW +, int nH +, int nD +) +{ + Init(); + + (void)Create( nW + ,nH + ,nD + ); +} + +wxBitmap::wxBitmap( + void* pData +, long lType +, int nWidth +, int nHeight +, int nDepth +) +{ + Init(); + + (void)Create( pData + ,lType + ,nWidth + ,nHeight + ,nDepth + ); +} + +wxBitmap::wxBitmap( + const wxString& rFilename +, long lType +) +{ + Init(); + + LoadFile( rFilename + ,(int)lType + ); +} + +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"); + } - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} -bool wxBitmap::Create(int w, int h, int d) -{ 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"); + } + + GetBitmapData()->m_depth = wxDisplayDepth(); + } + + SetHBITMAP((WXHBITMAP)hbmp); - return M_BITMAPDATA->m_ok; +#if WXWIN_COMPATIBILITY_2 + GetBitmapData()->m_ok = hbmp != 0; +#endif // WXWIN_COMPATIBILITY_2 + + return Ok(); } bool wxBitmap::LoadFile(const wxString& filename, long type) { UnRef(); - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); + wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); - if ( handler == NULL ) { - wxLogWarning("no bitmap handler for type %d defined.", type); + if ( handler ) + { + m_refData = new wxBitmapRefData; - return FALSE; + return handler->LoadFile(this, filename, type, -1, -1); } + else + { + wxImage image; + if ( !image.LoadFile( filename, type ) || !image.Ok() ) + return FALSE; - return handler->LoadFile(this, filename, type, -1, -1); + *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 = FindHandler(type); + wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); - 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; - } - - return handler->SaveFile(this, filename, type, palette); -} - -void wxBitmap::SetWidth(int w) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_width = w; -} + wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); -void wxBitmap::SetHeight(int h) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + if ( handler ) + { + return handler->SaveFile(this, filename, type, palette); + } + else + { + // FIXME what about palette? shouldn't we use it? + wxImage image( *this ); + if (!image.Ok()) + return FALSE; - M_BITMAPDATA->m_height = h; + return image.SaveFile( filename, type ); + } } -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; - - 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; -} + EnsureHasData(); -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 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 - return FALSE; + 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; + } + if (!bitmap.Ok()) + { + return FALSE; + } + + // 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 - */ +// ---------------------------------------------------------------------------- +// wxBitmapHandler +// ---------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) +bool wxBitmapHandler::Create(wxGDIImage *image, + void *data, + long flags, + int width, int height, int depth) +{ + wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); -bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth) + 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::LoadFile(wxBitmap *bitmap, const wxString& name, long type, - int desiredWidth, int desiredHeight) +bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), + const wxString& WXUNUSED(name), + long WXUNUSED(type), + int WXUNUSED(desiredWidth), + int WXUNUSED(desiredHeight)) { return FALSE; } -bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette) +bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), + const wxString& WXUNUSED(name), + int WXUNUSED(type), + const wxPalette *WXUNUSED(palette)) { return FALSE; } -/* - * Standard handlers - */ +// ---------------------------------------------------------------------------- +// DIB functions +// ---------------------------------------------------------------------------- -/* TODO: bitmap handlers, a bit like this: -class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler +bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel, + HPALETTE hPal, LPBITMAPINFO* lpDIBHeader) { - DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) -public: - inline wxBMPResourceHandler() - { - m_name = "Windows bitmap resource"; - m_extension = ""; - m_type = wxBITMAP_TYPE_BMP_RESOURCE; - }; + unsigned long i, headerSize; + LPBITMAPINFO lpDIBheader = NULL; + LPPALETTEENTRY lpPe = NULL; - 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; - } + // 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 wxBitmap::InitStandardHandlers() +void wxFreeDIB(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); -*/ + free(lpDIBHeader); } + diff --git a/src/os2/icon.cpp b/src/os2/icon.cpp index 60614db09c..ffece6b1f3 100644 --- a/src/os2/icon.cpp +++ b/src/os2/icon.cpp @@ -17,12 +17,11 @@ #endif #ifndef WX_PRECOMP -#include -#include "wx/setup.h" -#include "wx/list.h" -#include "wx/utils.h" -#include "wx/app.h" -#include "wx/icon.h" + #include "wx/defs.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/app.h" + #include "wx/icon.h" #endif #include "wx/os2/private.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); + if ( 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) -{ - UnRef(); - - m_refData = new wxIconRefData; - - wxBitmapHandler *handler = FindHandler(type); - - if ( handler ) - return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); - 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) +bool wxIcon::LoadFile( + const wxString& rFilename +, long lType +, int nDesiredWidth +, int nDesiredHeight +) { -// 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); - } + wxGDIImageHandler* pHandler = FindHandler(type); + + UnRef(); + m_refData = new wxIconRefData; + + if (pHandler) + return(pHandler->Load( this + ,rFilename + ,lType + ,nDesiredWidth + ,nDesiredHeight + )); 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); } diff --git a/src/os2/statbmp.cpp b/src/os2/statbmp.cpp index bc19e866fe..a04f0547cd 100644 --- a/src/os2/statbmp.cpp +++ b/src/os2/statbmp.cpp @@ -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); - - int x, y; - int w, h; - GetPosition(&x, &y); - GetSize(&w, &h); - - // TODO: redraw bitmap + m_pImage = new wxBitmap((const wxBitmap &)rBitmap); + + int nX; + int nY; + int nW; + int nH; + + 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); } - diff --git a/src/os2/thread.cpp b/src/os2/thread.cpp index 04769f4cb2..7b4a4643c8 100644 --- a/src/os2/thread.cpp +++ b/src/os2/thread.cpp @@ -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 - ); - - 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 ) + // need a way to finish GUI processing before killing the thread + // until then we just exit + + if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread()) { - wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject")); + wxMutexGuiLeave(); } +#else // !wxUSE_GUI + + // 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) ) + ::DosExit(0, 0); + // probably won't get this far, but + if (IsDetached()) { - wxLogLastError("GetExitCodeThread"); - - rc = (ExitCode)-1; - } - - 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()); - delete this; + 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 // ---------------------------------------------------------------------------- -- 2.45.2