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

bitmap and image updates

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

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

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

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

@@ -1,9 +1,9 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.h
// Name: wx/os2/bitmap.h
// Purpose: wxBitmap class
// Author: David Webster
// Modified by:
// Created: 10/13/99
// Created: 11/28/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
@@ -12,196 +12,337 @@
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/gdiobj.h"
#ifdef __GNUG__
#pragma interface "bitmap.h"
#endif
#include "wx/os2/gdiimage.h"
#include "wx/gdicmn.h"
#include "wx/palette.h"
// Bitmap
class WXDLLEXPORT wxDC;
class WXDLLEXPORT wxControl;
class WXDLLEXPORT wxBitmap;
class WXDLLEXPORT wxBitmapHandler;
class WXDLLEXPORT wxIcon;
class WXDLLEXPORT wxMask;
class WXDLLEXPORT wxCursor;
class WXDLLEXPORT wxControl;
// A mask is a mono bitmap used for drawing bitmaps
// transparently.
class WXDLLEXPORT wxMask: public wxObject
// ----------------------------------------------------------------------------
// Bitmap data
//
// 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:
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;
int m_nNumColors;
wxPalette m_vBitmapPalette;
int m_nQuality;
WXHBITMAP m_hBitmap;
wxDC * m_selectedInto; // So bitmap knows whether it's been selected into
// OS2-specific
// ------------
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:
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);
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);
// Copy constructors
inline wxBitmap(const wxBitmap& rBitmap)
{ Init(); Ref(rBitmap); }
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;
};
// Initialize with raw data
wxBitmap( const char bits[]
,int nWidth
,int nHeight
,int nDepth = 1
);
#define M_BITMAPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
// Initialize with XPM data
wxBitmap( char** ppData
,wxControl* pAnItem = NULL
);
class WXDLLEXPORT wxBitmap: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxBitmap)
// Load a file or resource
wxBitmap( const wxString& rName
,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:
wxBitmap(); // Platform-specific
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap( int nWidth
,int nHeight
,int nDepth = -1
);
// Copy constructors
wxBitmap(const wxBitmap& bitmap);
// 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); }
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
wxBitmap& operator=(const wxBitmap& rBitmap)
{
if ( m_refData != rBitmap.m_refData )
Ref(rBitmap);
return(*this);
}
// Initialize with XPM data
wxBitmap(char **data, wxControl *anItem = NULL);
wxBitmap& operator=(const wxIcon& rIcon)
{
(void)CopyFromIcon(rIcon);
// Load a file or resource
wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
return(*this);
}
// New constructor for generalised creation from data
wxBitmap(void *data, long type, int width, int height, int depth = 1);
wxBitmap& operator=(const wxCursor& rCursor)
{
(void)CopyFromCursor(rCursor);
return (*this);
}
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1);
~wxBitmap();
virtual ~wxBitmap();
virtual bool Create(int width, int height, int depth = -1);
virtual bool Create(void *data, long type, int width, int height, int depth = 1);
virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& rIcon);
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);
// copies the contents and mask of the given cursor to the bitmap
bool CopyFromCursor(const wxCursor& rCursor);
virtual bool Create( int nWidth
,int nHeight
,int nDepth = -1
);
virtual bool Create( void* pData
,long lType
,int nWidth
,int nHeight
,int nDepth = 1
);
virtual bool LoadFile( const wxString& rName
,long lType = wxBITMAP_TYPE_BMP_RESOURCE
);
virtual bool SaveFile( const wxString& rName
,int lType
,const wxPalette* pCmap = NULL
);
inline wxBitmapRefData* GetBitmapData() const
{ return (wxBitmapRefData *)m_refData; }
inline int GetQuality() const
{ return (GetBitmapData() ? GetBitmapData()->m_quality : 0); }
void SetQuality(int nQ);
wxPalette* GetPalette() const
{ return (GetBitmapData() ? (& GetBitmapData()->m_bitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& rPalette);
inline wxMask* GetMask() const
{ return (GetBitmapData() ? GetBitmapData()->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask* pMask) ;
inline bool operator==(const wxBitmap& rBitmap)
{ return m_refData == rBitmap.m_refData; }
inline bool operator!=(const wxBitmap& rBitmap)
{ return m_refData != rBitmap.m_refData; }
#if WXWIN_COMPATIBILITY_2
void SetOk(bool bIsOk);
#endif // WXWIN_COMPATIBILITY_2
#if WXWIN_COMPATIBILITY
inline wxPalette *GetColourMap(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 wxPalette* GetColourMap() const
{ return GetPalette(); }
inline wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask *mask) ;
inline void SetColourMap(wxPalette* pCmap)
{ 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; }
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
// Implementation
public:
void SetHBITMAP(WXHBITMAP bmp);
inline WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
inline void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; }
inline wxDC *GetSelectedInto(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_selectedInto : (wxDC*) NULL); }
bool FreeResource(bool force = FALSE);
inline void SetHBITMAP(WXHBITMAP hHmp)
{ SetHandle((WXHANDLE)bmp); }
// 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 WXHBITMAP GetHBITMAP() const
{ return (WXHBITMAP)GetHandle(); }
inline void SetSelectedInto(wxDC* pDc)
{ if (GetBitmapData()) GetBitmapData()->m_selectedInto = pDc; }
inline wxDC* GetSelectedInto() const
{ return (GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC*) NULL); }
// Creates a bitmap that matches the device context's depth, from an
// arbitray bitmap. At present, the original bitmap must have an associated
// palette. (TODO: use a default palette if no palette exists.) This
// function is necessary for you to Blit an arbitrary bitmap (which may
// have the wrong depth). wxDC::SelectObject will compare the depth of the
// bitmap with the DC's depth, and create a new bitmap if the depths
// differ. Eventually we should perhaps make this a public API function so
// that an app can efficiently produce bitmaps of the correct depth. The
// Windows solution is to use SetDibBits to blit an arbotrary DIB directly
// to a DC, but this is too Windows-specific, hence this solution of
// quietly converting the wxBitmap. Contributed by Frederic Villeneuve
// <frederic.villeneuve@natinst.com>
wxBitmap GetBitmapForDC(wxDC& rDc) const;
protected:
// common part of all ctors
void Init();
inline virtual wxGDIImageRefData* CreateData() const
{ return new wxBitmapRefData; }
private:
bool CopyFromIconOrCursor(const wxGDIImage& rIcon);
DECLARE_DYNAMIC_CLASS(wxBitmap)
};
// ----------------------------------------------------------------------------
// wxMask: a mono bitmap used for drawing bitmaps transparently.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxMask : public wxObject
{
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
// _WX_BITMAP_H_

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

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

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

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

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

@@ -16,6 +16,9 @@
// global settings
// ----------------------------------------------------------------------------
// define this to 1 if you want icons to behave as bitmaps
#define wxICON_IS_BITMAP 0
// define this to 0 when building wxBase library
#define wxUSE_GUI 1
@@ -163,7 +166,7 @@
// Some databases/ODBC drivers only allow forward scrolling cursors.
// Unless you specifically want to use backward scrolling
// cursors, and you know that all of the databases/ODBC drivers
// that you will use these odbc classes with allow backward
// that you will use these odbc classes with allow backward
// scrolling cursors, this setting should remain set to 1
// for maximum database/driver compatibilty

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

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

13
src/os2/app.cpp
View File

@@ -185,13 +185,14 @@ bool wxApp::RegisterWindowClasses(
HAB vHab
)
{
APIRET rc;
if (!::WinRegisterClass( vHab
,wxFrameClassName
,(PFNWP)wxWndProc
,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME
,0
))
if ((rc = ::WinRegisterClass( vHab
,wxFrameClassName
,(PFNWP)wxWndProc
,CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST | CS_CLIPCHILDREN | CS_FRAME
,0
)) != 0)
{
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
#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"
@@ -31,120 +30,77 @@
#include "wx/icon.h"
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxIconBase)
#endif
/*
* Icons
*/
// ============================================================================
// implementation
// ============================================================================
wxIconRefData::wxIconRefData()
// ----------------------------------------------------------------------------
// wxIconRefData
// ----------------------------------------------------------------------------
void wxIconRefData::Free()
{
m_hIcon = (WXHICON) NULL ;
if ( m_hIcon )
::DestroyIcon((HICON) m_hIcon);
}
wxIconRefData::~wxIconRefData()
{
if ( m_hIcon )
return;
// TODO ::DestroyIcon((HICON) m_hIcon);
}
// ----------------------------------------------------------------------------
// wxIcon
// ----------------------------------------------------------------------------
wxIcon::wxIcon()
{
}
wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height))
wxIcon::wxIcon(
const char WXUNUSED(bits)[]
, int WXUNUSED(nWidth)
, int WXUNUSED(nHeight)
)
{
}
wxIcon::wxIcon(const wxString& icon_file, long flags,
int desiredWidth, int desiredHeight)
wxIcon::wxIcon(
const wxString& rIconFile
, long lFlags
, int nDesiredWidth
, int nDesiredHeight
)
{
LoadFile(icon_file, flags, desiredWidth, desiredHeight);
LoadFile( rIconFile
,lFlags
,nDesiredWidth
,nDesiredHeight
);
}
wxIcon::~wxIcon()
{
}
bool wxIcon::LoadFile(const wxString& filename, long type,
int desiredWidth, int desiredHeight)
bool wxIcon::LoadFile(
const wxString& rFilename
, long lType
, int nDesiredWidth
, int nDesiredHeight
)
{
UnRef();
wxGDIImageHandler* pHandler = FindHandler(type);
m_refData = new wxIconRefData;
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)
{
// 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);
}
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);
}

135
src/os2/statbmp.cpp
View File

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

107
src/os2/thread.cpp
View File

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