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

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

include/wx/generic/wizard.h

@@ -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
     // -------------------------------

include/wx/msw/bitmap.h

@@ -56,8 +56,9 @@ public:
   bool Create(const wxBitmap& bitmap);
 
   // Implementation
-  inline WXHBITMAP GetMaskBitmap(void) const { return m_maskBitmap; }
+  WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
-  inline void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
+  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; }
+  void SetName(const wxString& name) { m_name = name; }
-  inline void SetExtension(const wxString& ext) { m_extension = ext; }
+  void SetExtension(const wxString& ext) { m_extension = ext; }
-  inline void SetType(long type) { m_type = type; }
+  void SetType(long type) { m_type = type; }
-  inline wxString GetName(void) const { return m_name; }
+  wxString GetName() const { return m_name; }
-  inline wxString GetExtension(void) const { return m_extension; }
+  wxString GetExtension() const { return m_extension; }
-  inline long GetType(void) const { return m_type; }
+  long GetType() const { return m_type; }
 protected:
   wxString  m_name;
   wxString  m_extension;
@@ -116,15 +117,14 @@ protected:
 
 class WXDLLEXPORT wxBitmap: public wxGDIObject
 {
-  DECLARE_DYNAMIC_CLASS(wxBitmap)
-
 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);
+    wxBitmap(const wxBitmap& bitmap) { Init(); Ref(bitmap); }
 
     // Initialize with raw data
     wxBitmap(const char bits[], int width, int height, int depth = 1);
@@ -143,42 +143,57 @@ public:
 
     // 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);
+    wxBitmap(const wxIcon& icon) { Init(); CopyFromIcon(icon); }
 
-  ~wxBitmap();
+    wxBitmap& operator=(const wxBitmap& bitmap)
+    {
+        if ( m_refData != bitmap.m_refData )
+            Ref(bitmap);
+        return *this;
+    }
+
+    wxBitmap& operator=(const wxIcon& icon)
+    {
+        (void)CopyFromIcon(icon);
+
+        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);
 
-  inline bool Ok(void) const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
+    bool Ok() const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
-  inline int GetWidth(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
+    int GetWidth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_width : 0); }
-  inline int GetHeight(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
+    int GetHeight() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_height : 0); }
-  inline int GetDepth(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
+    int GetDepth() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_depth : 0); }
-  inline int GetQuality(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 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(); }
+    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); }
+    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); }
+    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 inline wxList& GetHandlers(void) { return sm_handlers; }
+    static wxList& GetHandlers() { return sm_handlers; }
     static void AddHandler(wxBitmapHandler *handler);
     static void InsertHandler(wxBitmapHandler *handler);
     static bool RemoveHandler(const wxString& name);
@@ -188,15 +203,16 @@ public:
 
     static void InitStandardHandlers();
     static void CleanUpHandlers();
+
 protected:
     static wxList sm_handlers;
 
     // Implementation
 public:
     void SetHBITMAP(WXHBITMAP bmp);
-  inline WXHBITMAP GetHBITMAP(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
+    WXHBITMAP GetHBITMAP() const { return (M_BITMAPDATA ? M_BITMAPDATA->m_hBitmap : 0); }
-  inline void SetSelectedInto(wxDC *dc) { if (M_BITMAPDATA) M_BITMAPDATA->m_selectedInto = dc; }
+    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); }
+    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
@@ -212,6 +228,12 @@ public:
     // 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

include/wx/wizard.h

@@ -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

src/common/object.cpp

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

src/generic/wizard.cpp

@@ -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

src/msw/bitmap.cpp

@@ -93,59 +93,77 @@ wxBitmapRefData::~wxBitmapRefData()
 
 wxList wxBitmap::sm_handlers;
 
-wxBitmap::wxBitmap()
+// this function should be called from all wxBitmap ctors
+void wxBitmap::Init()
 {
+    // m_refData = NULL; done in the base class ctor
+
     if ( wxTheBitmapList )
         wxTheBitmapList->AddBitmap(this);
 }
 
-wxBitmap::wxBitmap(const wxIcon& icon)
+bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 {
-    if ( wxTheBitmapList )
+    UnRef();
-        wxTheBitmapList->AddBitmap(this);
 
     if ( !icon.Ok() )
-        return;
+        return FALSE;
 
     int width = icon.GetWidth(),
         height = icon.GetHeight();
 
-    HDC hdc = ::CreateCompatibleDC(NULL);   // screen DC
+    HICON hicon = (HICON) icon.GetHICON();
-    HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc, width, height);
+
+    // 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)
+    return TRUE;
-{
-    Ref(bitmap);
-
-    if ( wxTheBitmapList )
-        wxTheBitmapList->AddBitmap(this);
 }
 
 wxBitmap::~wxBitmap()
 {
     if (wxTheBitmapList)
         wxTheBitmapList->DeleteObject(this);
+
+    delete GetMask();
 }
 
 bool wxBitmap::FreeResource(bool WXUNUSED(force))
@@ -175,6 +193,8 @@ bool wxBitmap::FreeResource(bool WXUNUSED(force))
 
 wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
 {
+    Init();
+
     m_refData = new wxBitmapRefData;
 
     M_BITMAPDATA->m_width = the_width ;
@@ -190,39 +210,35 @@ wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits
         M_BITMAPDATA->m_ok = FALSE;
 
     M_BITMAPDATA->m_selectedInto = NULL;
-
-  if ( wxTheBitmapList )
-    wxTheBitmapList->AddBitmap(this);
 }
 
 // Create from XPM data
 wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem))
 {
+    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 )
+    (void)Create(w, h, d);
-    wxTheBitmapList->AddBitmap(this);
 }
 
 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
 {
-  (void) Create(data, type, width, height, depth);
+    Init();
 
-  if ( wxTheBitmapList )
+    (void) Create(data, type, width, height, depth);
-    wxTheBitmapList->AddBitmap(this);
 }
 
 wxBitmap::wxBitmap(const wxString& filename, long type)
 {
-  LoadFile(filename, (int)type);
+    Init();
 
-  if ( wxTheBitmapList )
+    LoadFile(filename, (int)type);
-    wxTheBitmapList->AddBitmap(this);
 }
 
 bool wxBitmap::Create(int w, int h, int d)

src/msw/bmpbuttn.cpp

@@ -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 )
 {

src/msw/stattext.cpp

@@ -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') ) {
+            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();