AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

1. wxBitmap copy ctor and operator=() taking wxIcon added

Browse Source 
2. wxBitmapButton focus rect looks a bit better and it respects the icon
   mask
3. wxWizard::GetPageSize() added


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4550 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin 1999-11-14 02:22:27 +00:00
parent 954269e6dd
commit 4fe5383d6c
8 changed files with 218 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/wx/generic/wizard.h
View File

@ -27,6 +27,7 @@ public:
// implement base class pure virtuals
virtual bool RunWizard(wxWizardPage *firstPage);
virtual wxWizardPage *GetCurrentPage() const;
virtual wxSize GetPageSize() const;
// implementation only from now on
// -------------------------------

188
include/wx/msw/bitmap.h
View File

@ -6,14 +6,14 @@
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#ifdef __GNUG__
#pragma interface "bitmap.h"
#pragma interface "bitmap.h"
#endif
#include "wx/gdiobj.h"
@ -56,8 +56,9 @@ public:
bool Create(const wxBitmap& bitmap);
// Implementation
inline WXHBITMAP GetMaskBitmap(void) const { return m_maskBitmap; }
inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
protected:
WXHBITMAP m_maskBitmap;
};
@ -94,19 +95,19 @@ class WXDLLEXPORT wxBitmapHandler: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
public:
wxBitmapHandler(void) { m_name = ""; m_extension = ""; m_type = 0; };
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(void) const { return m_name; }
inline wxString GetExtension(void) const { return m_extension; }
inline long GetType(void) const { return m_type; }
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(long type) { m_type = type; }
wxString GetName() const { return m_name; }
wxString GetExtension() const { return m_extension; }
long GetType() const { return m_type; }
protected:
wxString m_name;
wxString m_extension;
@ -116,102 +117,123 @@ protected:
class WXDLLEXPORT wxBitmap: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxBitmap)
friend class WXDLLEXPORT wxBitmapHandler;
friend class WXDLLEXPORT wxBitmapHandler;
public:
wxBitmap(); // Platform-specific
// default ctor creates an invalid bitmap, you must Create() it later
wxBitmap() { Init(); }
// Copy constructors
wxBitmap(const wxBitmap& bitmap);
// Copy constructors
wxBitmap(const wxBitmap& bitmap) { Init(); Ref(bitmap); }
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(char **data, wxControl *anItem = NULL);
// 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);
// Load a file or resource
wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
// New constructor for generalised creation from data
wxBitmap(void *data, long type, int width, int height, int depth = 1);
// New constructor for generalised creation from data
wxBitmap(void *data, long type, int width, int height, int depth = 1);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1);
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
wxBitmap(const wxIcon& icon);
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
wxBitmap(const wxIcon& icon) { Init(); CopyFromIcon(icon); }
~wxBitmap();
wxBitmap& operator=(const wxBitmap& bitmap)
{
if ( m_refData != bitmap.m_refData )
Ref(bitmap);
return *this;
}
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);
wxBitmap& operator=(const wxIcon& icon)
{
(void)CopyFromIcon(icon);
inline bool Ok(void) const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
inline int GetWidth(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
inline int GetHeight(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
inline int GetDepth(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
inline int GetQuality(void) 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);
return *this;
}
virtual ~wxBitmap();
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& icon);
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);
bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
int GetQuality() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
void SetWidth(int w);
void SetHeight(int h);
void SetDepth(int d);
void SetQuality(int q);
void SetOk(bool isOk);
#if WXWIN_COMPATIBILITY
inline wxPalette *GetColourMap(void) const { return GetPalette(); }
void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
wxPalette *GetColourMap() const { return GetPalette(); }
void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
#endif
inline wxPalette* GetPalette(void) const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& palette);
wxPalette* GetPalette() const { return (M_BITMAPDATA ? (& M_BITMAPDATA->m_bitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& palette);
inline wxMask *GetMask(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask *mask) ;
wxMask *GetMask() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_bitmapMask : (wxMask*) NULL); }
void SetMask(wxMask *mask) ;
inline wxBitmap& operator = (const wxBitmap& bitmap) { if (*this == bitmap) return (*this); Ref(bitmap); return *this; }
bool operator==(const wxBitmap& bitmap) { return m_refData == bitmap.m_refData; }
bool operator!=(const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; }
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 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);
// Format handling
static inline wxList& GetHandlers(void) { 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();
static void InitStandardHandlers();
static void CleanUpHandlers();
protected:
static wxList sm_handlers;
static wxList sm_handlers;
// Implementation
// Implementation
public:
void SetHBITMAP(WXHBITMAP bmp);
inline WXHBITMAP GetHBITMAP(void) 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);
void SetHBITMAP(WXHBITMAP bmp);
WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; }
wxDC *GetSelectedInto() 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;
// 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;
protected:
// common part of all ctors
void Init();
private:
DECLARE_DYNAMIC_CLASS(wxBitmap)
};
#endif

4
include/wx/wizard.h
View File

@ -121,6 +121,10 @@ public:
// get the current page (NULL if RunWizard() isn't running)
virtual wxWizardPage *GetCurrentPage() const = 0;
// get the size available for the page: the wizards are not resizeable, so
// this size doesn't change
virtual wxSize GetPageSize() const = 0;
};
// include the real class declaration

12
src/common/object.cpp
View File

@ -355,13 +355,15 @@ void wxObject::Ref(const wxObject& clone)
void wxObject::UnRef()
{
if (m_refData) {
assert(m_refData->m_count > 0);
--(m_refData->m_count);
if (m_refData->m_count == 0)
if ( m_refData )
{
wxASSERT_MSG( m_refData->m_count > 0, _T("invalid ref data count") );
if ( !--m_refData->m_count )
delete m_refData;
m_refData = (wxObjectRefData *) NULL;
}
m_refData = (wxObjectRefData *) NULL;
}
/*

5
src/generic/wizard.cpp
View File

@ -265,6 +265,11 @@ wxWizardPage *wxWizard::GetCurrentPage() const
return m_page;
}
wxSize wxWizard::GetPageSize() const
{
return wxSize(m_width, m_height);
}
void wxWizard::OnCancel(wxCommandEvent& WXUNUSED(event))
{
// this function probably can never be called when we don't have an active

108
src/msw/bitmap.cpp
View File

@ -93,65 +93,83 @@ wxBitmapRefData::~wxBitmapRefData()
wxList wxBitmap::sm_handlers;
wxBitmap::wxBitmap()
// this function should be called from all wxBitmap ctors
void wxBitmap::Init()
{
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
// m_refData = NULL; done in the base class ctor
wxBitmap::wxBitmap(const wxIcon& icon)
{
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
UnRef();
if ( !icon.Ok() )
return;
return FALSE;
int width = icon.GetWidth(),
height = icon.GetHeight();
HDC hdc = ::CreateCompatibleDC(NULL); // screen DC
HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc, width, height);
HICON hicon = (HICON) icon.GetHICON();
// GetIconInfo() doesn't exist under Win16 and I don't know any other way
// to create a bitmap from icon there - but using this way we won't have
// the mask (FIXME)
#ifdef __WIN16__
// copy the icon to the bitmap
HDC hdcScreen = ::GetDC((HWND)NULL);
HDC hdc = ::CreateCompatibleDC(hdcScreen);
HBITMAP hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height);
HBITMAP hbmpOld = (HBITMAP)::SelectObject(hdc, hbitmap);
HICON hicon = (HICON) icon.GetHICON();
#if defined(__WIN32__) && !defined(__SC__) && !defined(__TWIN32__)
::DrawIconEx(hdc, 0, 0, hicon, width, height, 0, 0, DI_NORMAL);
#else
::DrawIcon(hdc, 0, 0, hicon);
#endif
::SelectObject(hdc, hbmpOld);
::DeleteDC(hdc);
::ReleaseDC((HWND)NULL, hdcScreen);
#else // Win32
ICONINFO iconInfo;
if ( !GetIconInfo(hicon, &iconInfo) )
{
wxLogLastError("GetIconInfo");
return FALSE;
}
HBITMAP hbitmap = iconInfo.hbmColor;
wxBitmap bmpMask(width, height, 1);
bmpMask.SetHBITMAP((WXHBITMAP)iconInfo.hbmMask);
SetMask(new wxMask(bmpMask));
#endif // Win16/32
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_width = width;
M_BITMAPDATA->m_height = height;
M_BITMAPDATA->m_depth = wxDisplayDepth();
M_BITMAPDATA->m_numColors = 0;
M_BITMAPDATA->m_hBitmap = (WXHBITMAP)hbitmap;
M_BITMAPDATA->m_ok = TRUE;
}
wxBitmap::wxBitmap(const wxBitmap& bitmap)
{
Ref(bitmap);
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
return TRUE;
}
wxBitmap::~wxBitmap()
{
if (wxTheBitmapList)
wxTheBitmapList->DeleteObject(this);
delete GetMask();
}
bool wxBitmap::FreeResource(bool WXUNUSED(force))
{
if ( !M_BITMAPDATA )
return FALSE;
return FALSE;
wxASSERT_MSG( !M_BITMAPDATA->m_selectedInto,
wxT("freeing bitmap still selected into wxMemoryDC") );
@ -175,54 +193,52 @@ bool wxBitmap::FreeResource(bool WXUNUSED(force))
wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
{
m_refData = new wxBitmapRefData;
Init();
M_BITMAPDATA->m_width = the_width ;
M_BITMAPDATA->m_height = the_height ;
M_BITMAPDATA->m_depth = no_bits ;
M_BITMAPDATA->m_numColors = 0;
m_refData = new wxBitmapRefData;
M_BITMAPDATA->m_hBitmap = (WXHBITMAP) CreateBitmap(the_width, the_height, 1, no_bits, bits);
M_BITMAPDATA->m_width = the_width ;
M_BITMAPDATA->m_height = the_height ;
M_BITMAPDATA->m_depth = no_bits ;
M_BITMAPDATA->m_numColors = 0;
if (M_BITMAPDATA->m_hBitmap)
M_BITMAPDATA->m_ok = TRUE;
else
M_BITMAPDATA->m_ok = FALSE;
M_BITMAPDATA->m_hBitmap = (WXHBITMAP) CreateBitmap(the_width, the_height, 1, no_bits, bits);
M_BITMAPDATA->m_selectedInto = NULL;
if (M_BITMAPDATA->m_hBitmap)
M_BITMAPDATA->m_ok = TRUE;
else
M_BITMAPDATA->m_ok = FALSE;
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
M_BITMAPDATA->m_selectedInto = NULL;
}
// Create from XPM data
wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem))
{
(void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
Init();
(void)Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
}
wxBitmap::wxBitmap(int w, int h, int d)
{
(void)Create(w, h, d);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
(void)Create(w, h, d);
}
wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
{
(void) Create(data, type, width, height, depth);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
(void) Create(data, type, width, height, depth);
}
wxBitmap::wxBitmap(const wxString& filename, long type)
{
LoadFile(filename, (int)type);
Init();
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
LoadFile(filename, (int)type);
}
bool wxBitmap::Create(int w, int h, int d)

18
src/msw/bmpbuttn.cpp
View File

@ -155,7 +155,20 @@ bool wxBitmapButton::MSWOnDraw(WXDRAWITEMSTRUCT *item)
y1 ++;
}
::BitBlt(hDC, x1, y1, bitmap->GetWidth(), bitmap->GetHeight(), memDC, 0, 0, SRCCOPY);
wxMask *mask = bitmap->GetMask();
if ( mask )
{
::MaskBlt(hDC, x1, y1, bitmap->GetWidth(), bitmap->GetHeight(), // dst
memDC, 0, 0, // src
(HBITMAP)mask->GetMaskBitmap(), 0, 0, // mask
MAKEROP4(SRCPAINT, SRCCOPY));
}
else
{
::BitBlt(hDC, x1, y1, bitmap->GetWidth(), bitmap->GetHeight(), // dst
memDC, 0, 0, // src
SRCCOPY);
}
if ( (state & ODS_DISABLED) && (GetWindowStyleFlag() & wxBU_AUTODRAW) )
DrawButtonDisable( (WXHDC) hDC, lpDIS->rcItem.left, lpDIS->rcItem.top, lpDIS->rcItem.right, lpDIS->rcItem.bottom, TRUE ) ;
@ -232,7 +245,8 @@ void wxBitmapButton::DrawFace( WXHDC dc, int left, int top, int right, int botto
DeleteObject(brushFace);
}
#define FOCUS_MARGIN 6
// VZ: should be at the very least less than wxDEFAULT_BUTTON_MARGIN
#define FOCUS_MARGIN 3
void wxBitmapButton::DrawButtonFocus( WXHDC dc, int left, int top, int right, int bottom, bool sel )
{

23
src/msw/stattext.cpp
View File

@ -99,15 +99,28 @@ wxSize wxStaticText::DoGetBestSize()
wxString text(wxGetWindowText(GetHWND()));
int widthTextMax = 0, widthLine,
heightTextTotal = 0, heightLine;
heightTextTotal = 0, heightLineDefault = 0, heightLine = 0;
wxString curLine;
for ( const wxChar *pc = text; ; pc++ ) {
if ( *pc == wxT('\n') || *pc == wxT('\0') ) {
GetTextExtent(curLine, &widthLine, &heightLine);
if ( widthLine > widthTextMax )
widthTextMax = widthLine;
heightTextTotal += heightLine;
if ( !curLine ) {
// we can't use GetTextExtent - it will return 0 for both width
// and height and an empty line should count in height
// calculation
if ( !heightLineDefault )
heightLineDefault = heightLine;
if ( !heightLineDefault )
GetTextExtent(_T("W"), NULL, &heightLineDefault);
heightTextTotal += heightLineDefault;
}
else {
GetTextExtent(curLine, &widthLine, &heightLine);
if ( widthLine > widthTextMax )
widthTextMax = widthLine;
heightTextTotal += heightLine;
}
if ( *pc == wxT('\n') ) {
curLine.Empty();