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

bitmap and image updates

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

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

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

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

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

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

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

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

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

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

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

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

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

13
src/os2/app.cpp
View File

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

832
src/os2/bitmap.cpp
View File

File diff suppressed because it is too large Load Diff

148
src/os2/icon.cpp
View File

@@ -17,12 +17,11 @@
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include <stdio.h> #include "wx/defs.h"
#include "wx/setup.h" #include "wx/list.h"
#include "wx/list.h" #include "wx/utils.h"
#include "wx/utils.h" #include "wx/app.h"
#include "wx/app.h" #include "wx/icon.h"
#include "wx/icon.h"
#endif #endif
#include "wx/os2/private.h" #include "wx/os2/private.h"
@@ -31,120 +30,77 @@
#include "wx/icon.h" #include "wx/icon.h"
#if !USE_SHARED_LIBRARIES #if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap) IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif #endif
/* // ============================================================================
* Icons // implementation
*/ // ============================================================================
wxIconRefData::wxIconRefData() // ----------------------------------------------------------------------------
// wxIconRefData
// ----------------------------------------------------------------------------
void wxIconRefData::Free()
{ {
m_hIcon = (WXHICON) NULL ; if ( m_hIcon )
::DestroyIcon((HICON) m_hIcon);
} }
wxIconRefData::~wxIconRefData() // ----------------------------------------------------------------------------
{ // wxIcon
if ( m_hIcon ) // ----------------------------------------------------------------------------
return;
// TODO ::DestroyIcon((HICON) m_hIcon);
}
wxIcon::wxIcon() wxIcon::wxIcon()
{ {
} }
wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height)) wxIcon::wxIcon(
const char WXUNUSED(bits)[]
, int WXUNUSED(nWidth)
, int WXUNUSED(nHeight)
)
{ {
} }
wxIcon::wxIcon(const wxString& icon_file, long flags, wxIcon::wxIcon(
int desiredWidth, int desiredHeight) const wxString& rIconFile
, long lFlags
, int nDesiredWidth
, int nDesiredHeight
)
{ {
LoadFile(icon_file, flags, desiredWidth, desiredHeight); LoadFile( rIconFile
,lFlags
,nDesiredWidth
,nDesiredHeight
);
} }
wxIcon::~wxIcon() wxIcon::~wxIcon()
{ {
} }
bool wxIcon::LoadFile(const wxString& filename, long type, bool wxIcon::LoadFile(
int desiredWidth, int desiredHeight) const wxString& rFilename
, long lType
, int nDesiredWidth
, int nDesiredHeight
)
{ {
UnRef(); wxGDIImageHandler* pHandler = FindHandler(type);
m_refData = new wxIconRefData; UnRef();
m_refData = new wxIconRefData;
wxBitmapHandler *handler = FindHandler(type); if (pHandler)
return(pHandler->Load( this
if ( handler ) ,rFilename
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); ,lType
else ,nDesiredWidth
return FALSE; ,nDesiredHeight
} ));
void wxIcon::SetHICON(WXHICON ico)
{
if ( !M_ICONDATA )
m_refData = new wxIconRefData;
M_ICONDATA->m_hIcon = ico;
}
bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
return FALSE;
}
bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
// TODO
/*
if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
{
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
}
else else
{ return(FALSE);
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;
} }

135
src/os2/statbmp.cpp
View File

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

107
src/os2/thread.cpp
View File

@@ -596,68 +596,17 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
} }
#if wxUSE_GUI #if wxUSE_GUI
// we can't just wait for the thread to terminate because it might be // need a way to finish GUI processing before killing the thread
// calling some GUI functions and so it will never terminate before we // until then we just exit
// process the Windows messages that result from these functions
ULONG ulrc; if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread())
do
{ {
ulrc = ::MsgWaitForMultipleObjects wxMutexGuiLeave();
(
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 )
{
wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
} }
#else // !wxUSE_GUI
// can't wait for yourself to end under OS/2 so just quit
#endif // wxUSE_GUI/!wxUSE_GUI #endif // wxUSE_GUI/!wxUSE_GUI
if ( IsMain() ) if ( IsMain() )
@@ -670,19 +619,10 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
} }
} }
if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) ) ::DosExit(0, 0);
// probably won't get this far, but
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; delete this;
} }
@@ -701,14 +641,19 @@ wxThreadError wxThread::Kill()
return wxTHREAD_NOT_RUNNING; return wxTHREAD_NOT_RUNNING;
::DosKillThread(m_internal->GetHandle()); ::DosKillThread(m_internal->GetHandle());
delete this; m_internal->Free();
if (IsDetached())
{
delete this;
}
return wxTHREAD_NO_ERROR; return wxTHREAD_NO_ERROR;
} }
void wxThread::Exit( void wxThread::Exit(
void* pStatus ExitCode pStatus
) )
{ {
m_internal->Free();
delete this; delete this;
::DosExit(EXIT_THREAD, ULONG(pStatus)); ::DosExit(EXIT_THREAD, ULONG(pStatus));
wxFAIL_MSG(wxT("Couldn't return from DosExit()!")); wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
@@ -730,11 +675,18 @@ unsigned int wxThread::GetPriority() const
return m_internal->GetPriority(); return m_internal->GetPriority();
} }
unsigned long wxThread::GetId() const
{
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
return (unsigned long)m_internal->GetId();
}
bool wxThread::IsRunning() const bool wxThread::IsRunning() const
{ {
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return m_internal->GetState() == STATE_RUNNING; return(m_internal->GetState() == STATE_RUNNING);
} }
bool wxThread::IsAlive() const bool wxThread::IsAlive() const
@@ -759,11 +711,6 @@ bool wxThread::TestDestroy()
return m_internal->GetState() == STATE_CANCELED; return m_internal->GetState() == STATE_CANCELED;
} }
wxThread::~wxThread()
{
delete m_internal;
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Automatic initialization for thread module // Automatic initialization for thread module
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------