class WXDLLEXPORT wxLog;
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
+HAB vHabmain;
// Force an exit from main loop
void WXDLLEXPORT wxExit(void);
DECLARE_EVENT_TABLE()
private:
- HAB m_vHab;
HMQ m_hMq;
QMSG m_vMsg;
};
/////////////////////////////////////////////////////////////////////////////
-// 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
#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
+ // <frederic.villeneuve@natinst.com>
+ 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 <frederic.villeneuve@natinst.com>
- 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_
#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_
-
// 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
// 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
// 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
/////////////////////////////////////////////////////////////////////////////
// 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_
#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
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)");
#include "wx/os2/private.h"
#include "wx/log.h"
+//#include "wx/msw/dib.h"
+#include "wx/image.h"
+
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
#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
// Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
{
- wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
-// TODO:
-/*
wxMemoryDC memDC;
+ wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
HPALETTE hPal = (HPALETTE) NULL;
LPBITMAPINFO lpDib;
void *lpBits = (void*) NULL;
-
- wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) );
-
- tmpBitmap.SetPalette(this->GetPalette());
- memDC.SelectObject(tmpBitmap);
- memDC.SetPalette(this->GetPalette());
-
- hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
-
- if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) )
+ if( GetPalette() && GetPalette()->Ok() )
{
- tmpBitmap.SetPalette(* this->GetPalette());
+ tmpBitmap.SetPalette(*GetPalette());
memDC.SelectObject(tmpBitmap);
- memDC.SetPalette(* this->GetPalette());
- hPal = (HPALETTE) this->GetPalette()->GetHPALETTE();
+ memDC.SetPalette(*GetPalette());
+ hPal = (HPALETTE)GetPalette()->GetHPALETTE();
}
else
{
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()
{
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;
}
// 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);
}
+
#endif
#ifndef WX_PRECOMP
-#include <stdio.h>
-#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"
#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);
}
// Purpose: wxStaticBitmap
// Author: David Webster
// Modified by:
-// Created: ??/??/98
+// Created: 11/27/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
// 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() ;
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
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);
}
-
}
#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() )
}
}
- 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;
}
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()!"));
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
return m_internal->GetState() == STATE_CANCELED;
}
-wxThread::~wxThread()
-{
- delete m_internal;
-}
-
// ----------------------------------------------------------------------------
// Automatic initialization for thread module
// ----------------------------------------------------------------------------
projects / wxWidgets.git / commitdiff
