1. wxSpinButton fixed: it now sends EVT_SPIN_UP/DOWN messages (and unnecessary

old code which didn't send them anyhow removed). It also allows to veto the
   changes, but this feature is not portable and as such is not documented.
2. wxBitmapBuuton doesn't lose its bitmap any more
3. wxImage::ConvertToBitmap() doesn't crash if image is !Ok() but just
   returns wxNullBitmap.
4. wxProgressDialog looks much nicer under Windows and its estimated/elapsed/
   remaining time fields actually show some non random numbers now
5. MDI client window doesn't flicker because wxMDIParentFrame doesn't position
   it at (0, 0) first before moving it to correct location
6. other minor fixes...


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3181 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/generic/progdlgg.h

@@ -1,4 +1,4 @@
-/////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////
 // Name:        progdlgg.h
 // Purpose:     wxProgressDialog class
 // Author:      Karsten Ball<6C>der
@@ -7,7 +7,7 @@
 // RCS-ID:      $Id$
 // Copyright:   (c) Karsten Ball<6C>der
 // Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////
 
 #ifndef __PROGDLGH_G__
 #define __PROGDLGH_G__
@@ -20,17 +20,19 @@
 
 #if wxUSE_PROGRESSDLG
 
-#include "wx/frame.h"
+#include "wx/dialog.h"
-#include "wx/time.h"
 
-/** Progress dialog which shows a moving progress bar.
+class WXDLLEXPORT wxButton;
+class WXDLLEXPORT wxStaticText;
+
+/* Progress dialog which shows a moving progress bar.
     Taken from the Mahogany project.*/
 
-class WXDLLEXPORT wxProgressDialog : public wxFrame
+class WXDLLEXPORT wxProgressDialog : public wxDialog
 {
 DECLARE_DYNAMIC_CLASS(wxProgressDialog)
 public:
-   /** Creates and displays dialog, disables event handling for other
+   /* Creates and displays dialog, disables event handling for other
        frames or parent frame to avoid recursion problems.
        @param title title for window
        @param message message to display in window
@@ -42,44 +44,51 @@ public:
                     int maximum = 100,
                     wxWindow *parent = NULL,
                     int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
-   /** Destructor.
+   /* Destructor.
        Re-enables event handling for other windows.
    */
    ~wxProgressDialog();
 
-   /** Update the status bar to the new value.
+   /* Update the status bar to the new value.
        @param value new value
        @param newmsg if used, new message to display
        @returns true if ABORT button has not been pressed
    */
    bool Update(int value = -1, const wxString& newmsg = _T(""));
 
-   /** Can be called to continue after the cancel button has been pressed, but
+   /* Can be called to continue after the cancel button has been pressed, but
        the program decided to continue the operation (e.g., user didn't
        confirm it)
    */
    void Resume() { m_state = Continue; }
 
-   /// Callback for optional abort button
+   // implementation from now on
-   void OnCancel(wxCommandEvent& WXUNUSED(event)) { m_state = Canceled; }
+       // callback for optional abort button
-
+   void OnCancel(wxCommandEvent& event);
-   /// callback to disable "hard" window closing
+       // callback to disable "hard" window closing
    void OnClose(wxCloseEvent& event);
 
 private:
-   /// the status bar
+   // create the label with given text and another one to show the time nearby
+   // under the lastWindow and modify it to be the same as the control created
+   // (which is returned)
+   wxStaticText *CreateLabel(const wxString& text, wxWindow **lastWindow);
+
+   // the status bar
    class wxGauge *m_gauge;
-   /// the message displayed
+   // the message displayed
    class wxStaticText *m_msg;
-   /// disable all or parent window only
+   // disable all or parent window only
    bool m_disableParentOnly;
-   /// displayed elapsed, estimated, remaining time
+   // displayed elapsed, estimated, remaining time
-   class wxStaticText *m_elapsed, *m_estimated, *m_remaining;
+   class wxStaticText *m_elapsed,
-   /// time when the dialog was created or NULL 
+                      *m_estimated,
-   class wxTime *m_time;
+                      *m_remaining;
-   /// parent window
+   // time when the dialog was created
-   class wxWindow *m_parent;
+   unsigned long m_timeStart;
-   /// continue processing or not (return value for Update())
+   // parent window
+   wxWindow *m_parent;
+   // continue processing or not (return value for Update())
    enum
    {
       Uncancelable = -1,   // dialog can't be canceled
@@ -87,9 +96,9 @@ private:
       Continue,            // can be cancelled but wasn't
       Finished             // finished, waiting to be removed from screen
    } m_state;
-   /// the abort button (or NULL if none)
+   // the abort button (or NULL if none)
-   class wxButton *m_btnAbort;
+   wxButton *m_btnAbort;
-   /// the maximum value
+   // the maximum value
    int m_maximum;
 
    DECLARE_EVENT_TABLE()

include/wx/msw/bmpbuttn.h

@@ -25,9 +25,10 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxButtonNameStr;
 class WXDLLEXPORT wxBitmapButton: public wxButton
 {
     DECLARE_DYNAMIC_CLASS(wxBitmapButton)
- public:
+
-  inline wxBitmapButton(void) { m_marginX = wxDEFAULT_BUTTON_MARGIN; m_marginY = wxDEFAULT_BUTTON_MARGIN; }
+public:
-  inline wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
+    wxBitmapButton() { m_marginX = wxDEFAULT_BUTTON_MARGIN; m_marginY = wxDEFAULT_BUTTON_MARGIN; }
+    wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
             const wxPoint& pos = wxDefaultPosition,
             const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
             const wxValidator& validator = wxDefaultValidator,
@@ -50,29 +51,30 @@ class WXDLLEXPORT wxBitmapButton: public wxButton
     virtual void SetBitmapLabel(const wxBitmap& bitmap);
 
 #if WXWIN_COMPATIBILITY
-  inline wxBitmap *GetBitmap(void) const { return (wxBitmap *) & m_buttonBitmap; }
+    wxBitmap *GetBitmap() const { return (wxBitmap *) & m_buttonBitmap; }
 #endif
 
-  inline wxBitmap& GetBitmapLabel(void) const { return (wxBitmap&) m_buttonBitmap; }
+    wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_buttonBitmap; }
-  inline wxBitmap& GetBitmapSelected(void) const { return (wxBitmap&) m_buttonBitmapSelected; }
+    wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_buttonBitmapSelected; }
-  inline wxBitmap& GetBitmapFocus(void) const { return (wxBitmap&) m_buttonBitmapFocus; }
+    wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_buttonBitmapFocus; }
-  inline wxBitmap& GetBitmapDisabled(void) const { return (wxBitmap&) m_buttonBitmapDisabled; }
+    wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_buttonBitmapDisabled; }
 
-  inline void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
+    void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
-  inline void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
+    void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
-  inline void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
+    void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
 
-  inline void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
+    void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
-  inline int GetMarginX(void) { return m_marginX; }
+    int GetMarginX() const { return m_marginX; }
-  inline int GetMarginY(void) { return m_marginY; }
+    int GetMarginY() const { return m_marginY; }
 
     // Implementation
+    virtual void SetDefault();
     virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item);
     virtual void DrawFace( WXHDC dc, int left, int top, int right, int bottom, bool sel );
     virtual void DrawButtonFocus( WXHDC dc, int left, int top, int right, int bottom, bool sel );
     virtual void DrawButtonDisable( WXHDC dc, int left, int top, int right, int bottom, bool with_marg );
 
- protected:
+protected:
     wxBitmap m_buttonBitmap;
     wxBitmap m_buttonBitmapSelected;
     wxBitmap m_buttonBitmapFocus;

include/wx/msw/spinbutt.h

@@ -52,15 +52,14 @@ public:
                 const wxString& name = "wxSpinButton");
 
 
-    // Attributes
+    // accessors
-    ////////////////////////////////////////////////////////////////////////////
-
     virtual int GetValue() const;
     virtual void SetValue(int val);
     virtual void SetRange(int minVal, int maxVal);
 
-    // IMPLEMENTATION
+    // implementation
     virtual bool MSWCommand(WXUINT param, WXWORD id);
+    virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
     virtual bool MSWOnScroll(int orientation, WXWORD wParam,
                              WXWORD pos, WXHWND control);
 };

include/wx/spinbutt.h

@@ -89,31 +89,28 @@ protected:
 // the wxSpinButton event
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSpinEvent : public wxScrollEvent
+class WXDLLEXPORT wxSpinEvent : public wxNotifyEvent
 {
     DECLARE_DYNAMIC_CLASS(wxSpinEvent)
 
 public:
     wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0)
-           : wxScrollEvent(commandType, id)
+           : wxNotifyEvent(commandType, id)
     {
     }
+
+    // get the current value of the control
+    int GetPosition() const { return m_commandInt; }
+    void SetPosition(int pos) { m_commandInt = pos; }
 };
 
 typedef void (wxEvtHandler::*wxSpinEventFunction)(wxSpinEvent&);
 
 // macros for handling spin events
-#define EVT_SPIN_UP(id, func) { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func }
+#define EVT_SPIN_UP(id, func) { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },
-#define EVT_SPIN_DOWN(id, func) { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func }
+#define EVT_SPIN_DOWN(id, func) { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },
 
-#define EVT_SPIN(id, func) \
+#define EVT_SPIN(id, func) { wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },
-  { wxEVT_SCROLL_TOP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_BOTTOM, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_PAGEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_PAGEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },\
-  { wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },
 
 #endif // wxUSE_SPINBTN
 

src/common/image.cpp

@@ -582,6 +582,9 @@ bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSE
 
 wxBitmap wxImage::ConvertToBitmap() const
 {
+    if ( !Ok() )
+        return wxNullBitmap;
+
     // sizeLimit is the MS upper limit for the DIB size
     int sizeLimit = 1024*768*3;
 

src/generic/progdlgg.cpp

@@ -9,8 +9,16 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
-#pragma implementation "progdlgg.h"
+    #pragma implementation "progdlgg.h"
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
@@ -20,6 +28,8 @@
     #pragma hdrstop
 #endif
 
+#if wxUSE_PROGRESSDLG
+
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/frame.h"
@@ -33,48 +43,56 @@
     #include "wx/dcclient.h"
 #endif
 
-#if wxUSE_PROGRESSDLG
-
 #include "wx/generic/progdlgg.h"
 
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
 #define LAYOUT_X_MARGIN 8
 #define LAYOUT_Y_MARGIN 8
 
-// wxTextEntryDialog
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+// update the label to show the given time (in seconds)
+static void SetTimeLabel(unsigned long val, wxStaticText *label);
+
+// ----------------------------------------------------------------------------
+// event tables
+// ----------------------------------------------------------------------------
 
 #if !USE_SHARED_LIBRARY
-    BEGIN_EVENT_TABLE(wxProgressDialog, wxFrame)
+    BEGIN_EVENT_TABLE(wxProgressDialog, wxDialog)
-       EVT_BUTTON(-1, wxProgressDialog::OnCancel)
+       EVT_BUTTON(wxID_CANCEL, wxProgressDialog::OnCancel)
        EVT_CLOSE(wxProgressDialog::OnClose)
     END_EVENT_TABLE()
 
-    IMPLEMENT_CLASS(wxProgressDialog, wxFrame)
+    IMPLEMENT_CLASS(wxProgressDialog, wxDialog)
 #endif
 
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxProgressDialog
+// ----------------------------------------------------------------------------
+
 wxProgressDialog::wxProgressDialog(wxString const &title,
                                    wxString const &message,
                                    int maximum,
                                    wxWindow *parent,
                                    int style)
+                : wxDialog(m_parent, -1, title)
 {
-   wxWindow *lastWindow = NULL;
     bool hasAbortButton = (style & wxPD_CAN_ABORT) != 0;
     m_state = hasAbortButton ? Continue : Uncancelable;
     m_disableParentOnly = (style & wxPD_APP_MODAL) == 0;
     m_parent = parent;
     m_maximum = maximum;
 
-   m_elapsed = m_estimated = m_remaining = NULL;
-   if ((style & (wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
-                 wxPD_REMAINING_TIME)) != 0)
-      m_time = new wxTime;
-   else
-      m_time = NULL;
-
-   wxFrame::Create(m_parent, -1, title, wxDefaultPosition,
-                   wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
-   SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-
     wxLayoutConstraints *c;
 
     wxClientDC dc(this);
@@ -89,7 +107,11 @@ wxProgressDialog::wxProgressDialog(wxString const &title,
     c->width.AsIs();
     c->height.AsIs();
     m_msg->SetConstraints(c);
-   lastWindow = m_msg;
+
+    wxSize sizeDlg, sizeLabel = m_msg->GetSize();
+    sizeDlg.y = 2*LAYOUT_Y_MARGIN + sizeLabel.y;
+
+    wxWindow *lastWindow = m_msg;
 
     if ( maximum > 0 )
     {
@@ -104,83 +126,66 @@ wxProgressDialog::wxProgressDialog(wxString const &title,
         m_gauge->SetConstraints(c);
         m_gauge->SetValue(0);
         lastWindow = m_gauge;
+
+        wxSize sizeGauge = m_gauge->GetSize();
+        sizeDlg.y += 2*LAYOUT_Y_MARGIN + sizeGauge.y;
     }
     else
         m_gauge = (wxGauge *)NULL;
 
+    // create the estimated/remaining/total time zones if requested
+    m_elapsed = m_estimated = m_remaining = NULL;
 
+    int nTimeLabels = 0;
     if ( style & wxPD_ELAPSED_TIME )
     {
-      m_elapsed = new wxStaticText(this, -1, "");
+        nTimeLabels++;
-      c = new wxLayoutConstraints;
-      c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
-      c->top.Below(lastWindow, LAYOUT_Y_MARGIN);
-      c->width.Absolute(60);
-      c->height.AsIs();
-      m_elapsed->SetConstraints(c);
 
-      wxStaticText *dummy = new wxStaticText(this, -1, _T("Elapsed time : "));
+        m_elapsed = CreateLabel(_T("Elapsed time : "), &lastWindow);
-      c = new wxLayoutConstraints;
-      c->right.LeftOf(m_elapsed);
-      c->top.SameAs(m_elapsed, wxTop, 0);
-      c->width.AsIs();
-      c->height.AsIs();
-      dummy->SetConstraints(c);      
-
-      lastWindow = m_elapsed;
     }
 
     if ( style & wxPD_ESTIMATED_TIME )
     {
-      m_estimated = new wxStaticText(this, -1, "");
+        nTimeLabels++;
-      c = new wxLayoutConstraints;
-      c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
-      c->top.Below(lastWindow, 0);
-      c->width.Absolute(60);
-      c->height.AsIs();
-      m_estimated->SetConstraints(c);
 
-      wxStaticText *dummy = new wxStaticText(this, -1, _T("Estimated time : "));
+        m_estimated = CreateLabel(_T("Estimated time : "), &lastWindow);
-      c = new wxLayoutConstraints;
-      c->right.LeftOf(m_estimated);
-      c->top.SameAs(m_estimated, wxTop, 0);
-      c->width.AsIs();
-      c->height.AsIs();
-      dummy->SetConstraints(c);      
-
-      lastWindow = m_estimated;
     }
 
     if ( style & wxPD_REMAINING_TIME )
     {
-      m_remaining = new wxStaticText(this, -1, "");
+        nTimeLabels++;
-      c = new wxLayoutConstraints;
-      c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
-      c->top.Below(lastWindow, 0);
-      c->width.Absolute(60);
-      c->height.AsIs();
-      m_remaining->SetConstraints(c);
 
-      wxStaticText *dummy = new wxStaticText(this, -1, _T("Remaining time : "));
+        m_remaining = CreateLabel(_T("Remaining time : "), &lastWindow);
-      c = new wxLayoutConstraints;
+    }
-      c->right.LeftOf(m_remaining);
-      c->top.SameAs(m_remaining, wxTop, 0);
-      c->width.AsIs();
-      c->height.AsIs();
-      dummy->SetConstraints(c);      
 
-      lastWindow = m_remaining;
+    if ( nTimeLabels > 0 )
+    {
+        // set it to the current time
+        m_timeStart = wxGetCurrentTime();
+
+        sizeDlg.y += nTimeLabels * (sizeLabel.y + LAYOUT_Y_MARGIN);
     }
 
     if ( hasAbortButton )
     {
-      m_btnAbort = new wxButton(this, -1, _("Cancel"));
+        m_btnAbort = new wxButton(this, wxID_CANCEL, _("Cancel"));
         c = new wxLayoutConstraints;
+
+        // Windows dialogs usually have buttons in the lower right corner
+#ifdef __WXMSW__
+        c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
+#else // !MSW
         c->centreX.SameAs(this, wxCentreX);
-      c->top.Below(lastWindow, 2*LAYOUT_Y_MARGIN);
+#endif // MSW/!MSW
-      c->width.AsIs();
+        c->bottom.SameAs(this, wxBottom, 2*LAYOUT_Y_MARGIN);
-      c->height.AsIs();
+
+        wxSize sizeBtn = wxButton::GetDefaultSize();
+        c->width.Absolute(sizeBtn.x);
+        c->height.Absolute(sizeBtn.y);
+
         m_btnAbort->SetConstraints(c);
+
+        sizeDlg.y += 2*LAYOUT_Y_MARGIN + sizeBtn.y;
     }
     else
         m_btnAbort = (wxButton *)NULL;
@@ -188,29 +193,62 @@ wxProgressDialog::wxProgressDialog(wxString const &title,
     SetAutoLayout(TRUE);
     Layout();
 
-   // calc the height of the dialog
+    sizeDlg.y += 2*LAYOUT_Y_MARGIN;
-   Fit();
+
-   // and set the width from it - unfortunately, Fit() makes the dialog way too
+    // try to make the dialog not square but rectangular of reasonabel width
-   // wide under Windows, so try to find a reasonable value for the width, not
+    sizeDlg.x = wxMax(widthText, 4*sizeDlg.y/3);
-   // too big and not too small
+    sizeDlg.x *= 3;
-   wxSize size = GetClientSize();
+    sizeDlg.x /= 2;
-   size.x = wxMax(3*widthText/2, 2*size.y);
+    SetClientSize(sizeDlg);
-   SetClientSize(size);
 
-   Show(TRUE);
     Centre(wxCENTER_FRAME | wxBOTH);
 
-   if(m_disableParentOnly)
+    if (m_disableParentOnly )
     {
-      if(m_parent)  m_parent->Enable(FALSE);
+        if ( m_parent )
+            m_parent->Enable(FALSE);
     }
     else
+    {
         wxEnableTopLevelWindows(FALSE);
+    }
 
+    Show(TRUE);
     Enable(TRUE); // enable this window
-   wxYield();
 }
 
+wxStaticText *wxProgressDialog::CreateLabel(const wxString& text,
+                                            wxWindow **lastWindow)
+{
+    wxLayoutConstraints *c;
+
+    wxStaticText *label = new wxStaticText(this, -1, _T("unknown"));
+    c = new wxLayoutConstraints;
+
+    // VZ: I like the labels be centered - if the others don't mind, you may
+    //     remove "#ifdef __WXMSW__" and use it for all ports
+#ifdef __WXMSW__
+    c->left.SameAs(this, wxCentreX, LAYOUT_X_MARGIN);
+#else // !MSW
+    c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
+#endif // MSW/!MSW
+    c->top.Below(*lastWindow, LAYOUT_Y_MARGIN);
+    c->width.AsIs();
+    c->height.AsIs();
+    label->SetConstraints(c);
+
+    wxStaticText *dummy = new wxStaticText(this, -1, text);
+    c = new wxLayoutConstraints;
+    c->right.LeftOf(label);
+    c->top.SameAs(label, wxTop, 0);
+    c->width.AsIs();
+    c->height.AsIs();
+    dummy->SetConstraints(c);
+
+    *lastWindow = label;
+
+    return label;
+}
 
 bool
 wxProgressDialog::Update(int value, const wxString& newmsg)
@@ -227,28 +265,13 @@ wxProgressDialog::Update(int value, const wxString& newmsg)
 
    if ( (m_elapsed || m_remaining || m_estimated) && (value != 0) )
    {
-      wxTime timenow;
+      unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
-      wxTime diff = timenow -  *m_time;
+      unsigned long estimated = elapsed * m_maximum / value;
-      unsigned long secs = diff.GetSecond() + 60 * diff.GetMinute() + 60 * 60 * diff.GetHour();
+      unsigned long remaining = estimated - elapsed;
-      unsigned long estim = secs * m_maximum / value; 
-      unsigned long remai = estim - secs; 
-      wxString s;
 
-      if (m_elapsed) 
+      SetTimeLabel(elapsed, m_elapsed);
-      {
+      SetTimeLabel(estimated, m_estimated);
-         s.Printf(_T("%i:%02i:%02i"), diff.GetHour(), diff.GetMinute(), diff.GetSecond());
+      SetTimeLabel(remaining, m_remaining);
-         if (s != m_elapsed->GetLabel()) m_elapsed->SetLabel(s);
-      }
-      if (m_estimated) 
-      {
-         s.Printf(_T("%i:%02i:%02i"), estim / (60 * 60), (estim / 60) % 60, estim % 60);
-         if (s != m_estimated->GetLabel()) m_estimated->SetLabel(s);
-      }
-      if (m_remaining) 
-      {
-         s.Printf(_T("%i:%02i:%02i"), remai / (60 * 60), (remai / 60) % 60, remai % 60);
-         if (s != m_remaining->GetLabel()) m_remaining->SetLabel(s);
-      }
    }
 
    if ( (value == m_maximum - 1) && !(GetWindowStyleFlag() & wxPD_AUTO_HIDE) )
@@ -259,25 +282,49 @@ wxProgressDialog::Update(int value, const wxString& newmsg)
            m_btnAbort->SetLabel(_("Close"));
        }
 
-/*I think the default should be the other way round. If the
-  application wants to set a "Done." message at the end, it should
-  supply it. Any serious objections to this change? Makes the
-  application programmers' work a little easier.
        if ( !newmsg )
        {
            // also provide the finishing message if the application didn't
            m_msg->SetLabel(_("Done."));
        }
-*/
+
+       // so that we return TRUE below and that out [Cancel] handler knew what
+       // to do
        m_state = Finished;
 
-       // so that we return TRUE below
-       m_state = Finished;
-   }
        wxYield();
+
+       (void)ShowModal();
+   }
+   else
+   {
+       // update the display
+       wxYield();
+   }
+
    return m_state != Canceled;
 }
 
+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
+
+void wxProgressDialog::OnCancel(wxCommandEvent& event)
+{
+    if ( m_state == Finished )
+    {
+        // this means that the count down is already finished and we're being
+        // shown as a modal dialog - so just let the default handler do the job
+        event.Skip();
+    }
+    else
+    {
+        // request to cancel was received, the next time Update() is called we
+        // will handle it
+        m_state = Canceled;
+    }
+}
+
 void wxProgressDialog::OnClose(wxCloseEvent& event)
 {
     if ( m_state == Uncancelable )
@@ -286,16 +333,40 @@ void wxProgressDialog::OnClose(wxCloseEvent& event)
         m_state = Canceled;
 }
 
+// ----------------------------------------------------------------------------
+// destruction
+// ----------------------------------------------------------------------------
 
 wxProgressDialog::~wxProgressDialog()
 {
     if ( m_disableParentOnly )
     {
-      if(m_parent) m_parent->Enable(TRUE);
+        if ( m_parent )
+            m_parent->Enable(TRUE);
     }
     else
+    {
         wxEnableTopLevelWindows(TRUE);
-   if (m_time) delete m_time;
+    }
 }
 
-#endif
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static void SetTimeLabel(unsigned long val, wxStaticText *label)
+{
+    if ( label )
+    {
+        wxString s;
+        unsigned long hours = val / 3600;
+        unsigned long minutes = (val % 3600) / 60;
+        unsigned long seconds = val % 60;
+        s.Printf(_T("%lu:%02lu:%02lu"), hours, minutes, seconds);
+
+        if ( s != label->GetLabel() )
+            label->SetLabel(s);
+    }
+}
+
+#endif // wxUSE_PROGRESSDLG

src/gtk/spinbutt.cpp

@@ -67,7 +67,6 @@ static void gtk_spinbutt_callback( GtkWidget *WXUNUSED(widget), wxSpinButton *wi
 
     wxSpinEvent event( command, win->GetId());
     event.SetPosition( value );
-    event.SetOrientation( wxVERTICAL );
     event.SetEventObject( win );
 
     win->GetEventHandler()->ProcessEvent( event );

src/gtk1/spinbutt.cpp

@@ -67,7 +67,6 @@ static void gtk_spinbutt_callback( GtkWidget *WXUNUSED(widget), wxSpinButton *wi
 
     wxSpinEvent event( command, win->GetId());
     event.SetPosition( value );
-    event.SetOrientation( wxVERTICAL );
     event.SetEventObject( win );
 
     win->GetEventHandler()->ProcessEvent( event );

src/msw/bmpbuttn.cpp

@@ -269,3 +269,7 @@ void wxBitmapButton::DrawButtonDisable( WXHDC dc, int left, int top, int right,
     ::SelectObject( (HDC) dc, old ) ;
 }
 
+void wxBitmapButton::SetDefault()
+{
+    wxButton::SetDefault();
+}

src/msw/button.cpp

@@ -166,7 +166,9 @@ void wxButton::SetDefault()
         SendMessage(GetWinHwnd(parent), DM_SETDEFID, m_windowId, 0L);
     }
 
-    if ( btnOldDefault )
+    // this doesn't work with bitmap buttons because it also removes the
+    // "ownerdrawn" style...
+    if ( btnOldDefault && !wxDynamicCast(btnOldDefault, wxBitmapButton) )
     {
         // remove the BS_DEFPUSHBUTTON style from the other button
         long style = GetWindowLong(GetHwndOf(btnOldDefault), GWL_STYLE);

src/msw/frame.cpp

@@ -175,7 +175,9 @@ void wxFrame::DoGetClientSize(int *x, int *y) const
   rect.bottom -= pt.y;
   rect.right -= pt.x;
 
+  if ( x )
     *x = rect.right;
+  if ( y )
     *y = rect.bottom;
 }
 

src/msw/mdi.cpp

@@ -192,10 +192,8 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
   if (style & wxCAPTION)
     msflags |= WS_CAPTION;
 
-  // Adding WS_CLIPCHILDREN causes children not to be properly
+  if (style & wxCLIP_CHILDREN)
-  // drawn when first displaying them.
+    msflags |= WS_CLIPCHILDREN;
-//  if (style & wxCLIP_CHILDREN)
-//    msflags |= WS_CLIPCHILDREN;
 
   wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
          msflags);
@@ -383,9 +381,9 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message,
             break;
 
         case WM_SIZE:
-            // we will leave this message to the base class version, but we
+            // as we don't (usually) resize the MDI client to exactly fit the
-            // must pass it to DefFrameProc() too
+            // client area (we put it below the toolbar, above statusbar &c),
-            MSWDefWindowProc(message, wParam, lParam);
+            // we should not pass this one to DefFrameProc
             break;
     }
 

src/msw/spinbutt.cpp

@@ -115,7 +115,7 @@ wxSpinButton::~wxSpinButton()
 
 int wxSpinButton::GetValue() const
 {
-    return LOWORD(::SendMessage(GetHwnd(), UDM_GETPOS, 0, 0));
+    return (short)LOWORD(::SendMessage(GetHwnd(), UDM_GETPOS, 0, 0));
 }
 
 void wxSpinButton::SetValue(int val)
@@ -133,52 +133,38 @@ void wxSpinButton::SetRange(int minVal, int maxVal)
 bool wxSpinButton::MSWOnScroll(int orientation, WXWORD wParam,
                                WXWORD pos, WXHWND control)
 {
-    if ( !control )
+    wxCHECK_MSG( control, FALSE, _T("scrolling what?") )
-        return FALSE;
 
-    wxSpinEvent event(wxEVT_NULL, m_windowId);
+    if ( wParam != SB_THUMBPOSITION )
-    event.SetPosition(pos);
-    event.SetOrientation(orientation);
-    event.SetEventObject(this);
-
-    switch ( wParam )
     {
-        case SB_TOP:
+        // probable SB_ENDSCROLL - we don't react to it
-            event.m_eventType = wxEVT_SCROLL_TOP;
-            break;
-
-        case SB_BOTTOM:
-            event.m_eventType = wxEVT_SCROLL_BOTTOM;
-            break;
-
-        case SB_LINEUP:
-            event.m_eventType = wxEVT_SCROLL_LINEUP;
-            break;
-
-        case SB_LINEDOWN:
-            event.m_eventType = wxEVT_SCROLL_LINEDOWN;
-            break;
-
-        case SB_PAGEUP:
-            event.m_eventType = wxEVT_SCROLL_PAGEUP;
-            break;
-
-        case SB_PAGEDOWN:
-            event.m_eventType = wxEVT_SCROLL_PAGEDOWN;
-            break;
-
-        case SB_THUMBTRACK:
-        case SB_THUMBPOSITION:
-            event.m_eventType = wxEVT_SCROLL_THUMBTRACK;
-            break;
-
-        default:
         return FALSE;
     }
 
+    wxSpinEvent event(wxEVT_SCROLL_THUMBTRACK, m_windowId);
+    event.SetPosition((short)pos);    // cast is important for negative values!
+    event.SetEventObject(this);
+
     return GetEventHandler()->ProcessEvent(event);
 }
 
+bool wxSpinButton::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
+{
+    LPNMUPDOWN lpnmud = (LPNMUPDOWN)lParam;
+
+    wxSpinEvent event(lpnmud->iDelta > 0 ? wxEVT_SCROLL_LINEUP
+                                         : wxEVT_SCROLL_LINEDOWN,
+                      m_windowId);
+    event.SetPosition(lpnmud->iPos + lpnmud->iDelta);
+    event.SetEventObject(this);
+
+    bool processed = GetEventHandler()->ProcessEvent(event);
+
+    *result = event.IsAllowed() ? 0 : 1;
+
+    return processed;
+}
+
 bool wxSpinButton::MSWCommand(WXUINT cmd, WXWORD id)
 {
     // No command messages

src/msw/window.cpp

@@ -1115,13 +1115,10 @@ void wxWindow::DoGetPosition(int *x, int *y) const
 
         // We may be faking the client origin. So a window that's really at (0,
         // 30) may appear (to wxWin apps) to be at (0, 0).
-        if ( parent )
-        {
         wxPoint pt(parent->GetClientAreaOrigin());
         point.x -= pt.x;
         point.y -= pt.y;
     }
-    }
 
     if ( x )
         *x = point.x;
@@ -1372,10 +1369,14 @@ void wxWindow::GetTextExtent(const wxString& string,
 
     ReleaseDC(hWnd, dc);
 
-    if ( x ) *x = sizeRect.cx;
+    if ( x )
-    if ( y ) *y = sizeRect.cy;
+        *x = sizeRect.cx;
-    if ( descent ) *descent = tm.tmDescent;
+    if ( y )
-    if ( externalLeading ) *externalLeading = tm.tmExternalLeading;
+        *y = sizeRect.cy;
+    if ( descent )
+        *descent = tm.tmDescent;
+    if ( externalLeading )
+        *externalLeading = tm.tmExternalLeading;
 }
 
 #if wxUSE_CARET && WXWIN_COMPATIBILITY
@@ -3319,7 +3320,10 @@ void wxGetCharSize(WXHWND wnd, int *x, int *y,wxFont *the_font)
         SelectObject(dc,was);
     }
     ReleaseDC((HWND)wnd, dc);
+
+    if ( x )
         *x = tm.tmAveCharWidth;
+    if ( y )
         *y = tm.tmHeight + tm.tmExternalLeading;
 
     //  if ( the_font )