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

@@ -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; }
+  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,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
+    // Copy constructors
-  wxBitmap(const wxBitmap& bitmap);
+    wxBitmap(const wxBitmap& bitmap) { Init(); Ref(bitmap); }
 
-  // Initialize with raw data
+    // Initialize with raw data
-  wxBitmap(const char bits[], int width, int height, int depth = 1);
+    wxBitmap(const char bits[], int width, int height, int depth = 1);
 
-  // Initialize with XPM data
+    // Initialize with XPM data
-  wxBitmap(char **data, wxControl *anItem = NULL);
+    wxBitmap(char **data, wxControl *anItem = NULL);
 
-  // Load a file or resource
+    // Load a file or resource
-  wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
+    wxBitmap(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
 
-  // New constructor for generalised creation from data
+    // New constructor for generalised creation from data
-  wxBitmap(void *data, long type, int width, int height, int depth = 1);
+    wxBitmap(void *data, long type, int width, int height, int depth = 1);
 
-  // If depth is omitted, will create a bitmap compatible with the display
+    // If depth is omitted, will create a bitmap compatible with the display
-  wxBitmap(int width, int height, int depth = -1);
+    wxBitmap(int width, int height, int depth = -1);
 
-  // we must have this, otherwise icons are silently copied into bitmaps using
+    // we must have this, otherwise icons are silently copied into bitmaps using
-  // the copy ctor but the resulting bitmap is invalid!
+    // 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;
+    }
 
-  virtual bool Create(int width, int height, int depth = -1);
+    wxBitmap& operator=(const wxIcon& icon)
-  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);
+        (void)CopyFromIcon(icon);
-  virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
 
-  inline bool Ok(void) const { return (M_BITMAPDATA && M_BITMAPDATA->m_ok); }
+        return *this;
-  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); }
+    virtual ~wxBitmap();
-  inline int GetQuality(void) const { return (M_BITMAPDATA ? M_BITMAPDATA->m_quality : 0); }
+
-  void SetWidth(int w);
+    // copies the contents and mask of the given (colour) icon to the bitmap
-  void SetHeight(int h);
+    bool CopyFromIcon(const wxIcon& icon);
-  void SetDepth(int d);
+
-  void SetQuality(int q);
+    virtual bool Create(int width, int height, int depth = -1);
-  void SetOk(bool isOk);
+    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(); }
+    wxPalette *GetColourMap() const { return GetPalette(); }
-  void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
+    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);
+    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) ;
+    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; }
+    // Format handling
-  inline bool operator != (const wxBitmap& bitmap) { return m_refData != bitmap.m_refData; }
+    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 void InitStandardHandlers();
-  static inline wxList& GetHandlers(void) { return sm_handlers; }
+    static void CleanUpHandlers();
-  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;
+    static wxList sm_handlers;
 
-  // Implementation
+    // Implementation
 public:
-  void SetHBITMAP(WXHBITMAP bmp);
+    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);
+    bool FreeResource(bool force = FALSE);
 
-  // Creates a bitmap that matches the device context's depth, from
+    // Creates a bitmap that matches the device context's depth, from
-  // an arbitray bitmap. At present, the original bitmap must have an
+    // an arbitray bitmap. At present, the original bitmap must have an
-  // associated palette. (TODO: use a default palette if no palette exists.)
+    // 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
+    // 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
+    // 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.
+    // 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
+    // Eventually we should perhaps make this a public API function so that
-  // an app can efficiently produce bitmaps of the correct depth.
+    // 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
+    // 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.
+    // this is too Windows-specific, hence this solution of quietly converting the wxBitmap.
-  // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
+    // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
-  wxBitmap GetBitmapForDC(wxDC& dc) const;
+    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,13 +355,15 @@ 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;
     }
-    m_refData = (wxObjectRefData *) NULL;
 }
 
 /*

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,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 )
+    // m_refData = NULL; done in the base class ctor
-    wxTheBitmapList->AddBitmap(this);
-}
 
-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
+    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))
 {
   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_refData = new wxBitmapRefData;
-  M_BITMAPDATA->m_height = the_height ;
-  M_BITMAPDATA->m_depth = no_bits ;
-  M_BITMAPDATA->m_numColors = 0;
 
-  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_hBitmap = (WXHBITMAP) CreateBitmap(the_width, the_height, 1, no_bits, bits);
-    M_BITMAPDATA->m_ok = TRUE;
-  else
-    M_BITMAPDATA->m_ok = FALSE;
 
-  M_BITMAPDATA->m_selectedInto = NULL;
+    if (M_BITMAPDATA->m_hBitmap)
+        M_BITMAPDATA->m_ok = TRUE;
+    else
+        M_BITMAPDATA->m_ok = FALSE;
 
-  if ( wxTheBitmapList )
+    M_BITMAPDATA->m_selectedInto = NULL;
-    wxTheBitmapList->AddBitmap(this);
 }
 
 // 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 )
+    (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') ) {
-            GetTextExtent(curLine, &widthLine, &heightLine);
+            if ( !curLine ) {
-            if ( widthLine > widthTextMax )
+                // we can't use GetTextExtent - it will return 0 for both width
-                widthTextMax = widthLine;
+                // and height and an empty line should count in height
-            heightTextTotal += heightLine;
+                // 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();