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

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

Browse Source 
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
This commit is contained in:
Vadim Zeitlin 1999-07-28 21:01:04 +00:00
parent f61815af20
commit 0655ad290a
14 changed files with 414 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
include/wx/generic/progdlgg.h
View File

@ -1,4 +1,4 @@
/////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////
// Name: progdlgg.h
// Purpose: wxProgressDialog class
// Author: Karsten Ballüder
@ -6,8 +6,8 @@
// Created: 09.05.1999
// RCS-ID: $Id$
// Copyright: (c) Karsten Ballüder
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// Licence: wxWindows license
////////////////////////////////////////////////////
#ifndef __PROGDLGH_G__
#define __PROGDLGH_G__
@ -20,17 +20,19 @@
#if wxUSE_PROGRESSDLG
#include "wx/frame.h"
#include "wx/time.h"
#include "wx/dialog.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
@ -39,47 +41,54 @@ public:
@param style is the bit mask of wxPD_XXX constants from wx/defs.h
*/
wxProgressDialog(const wxString &title, wxString const &message,
int maximum = 100,
wxWindow *parent = NULL,
int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
/** Destructor.
int maximum = 100,
wxWindow *parent = NULL,
int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
/* 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
void OnCancel(wxCommandEvent& WXUNUSED(event)) { m_state = Canceled; }
/// callback to disable "hard" window closing
// implementation from now on
// callback for optional abort button
void OnCancel(wxCommandEvent& event);
// 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
class wxStaticText *m_elapsed, *m_estimated, *m_remaining;
/// time when the dialog was created or NULL
class wxTime *m_time;
/// parent window
class wxWindow *m_parent;
/// continue processing or not (return value for Update())
// displayed elapsed, estimated, remaining time
class wxStaticText *m_elapsed,
*m_estimated,
*m_remaining;
// time when the dialog was created
unsigned long m_timeStart;
// 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)
class wxButton *m_btnAbort;
/// the maximum value
// the abort button (or NULL if none)
wxButton *m_btnAbort;
// the maximum value
int m_maximum;
DECLARE_EVENT_TABLE()

90
include/wx/msw/bmpbuttn.h
View File

@ -24,61 +24,63 @@ 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; }
inline wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
DECLARE_DYNAMIC_CLASS(wxBitmapButton)
bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
public:
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,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
virtual void SetLabel(const wxBitmap& bitmap)
{
SetBitmapLabel(bitmap);
}
bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetBitmapLabel(const wxBitmap& bitmap);
virtual void SetLabel(const wxBitmap& bitmap)
{
SetBitmapLabel(bitmap);
}
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; }
inline wxBitmap& GetBitmapSelected(void) const { return (wxBitmap&) m_buttonBitmapSelected; }
inline wxBitmap& GetBitmapFocus(void) const { return (wxBitmap&) m_buttonBitmapFocus; }
inline wxBitmap& GetBitmapDisabled(void) const { return (wxBitmap&) m_buttonBitmapDisabled; }
wxBitmap& GetBitmapLabel() const { return (wxBitmap&) m_buttonBitmap; }
wxBitmap& GetBitmapSelected() const { return (wxBitmap&) m_buttonBitmapSelected; }
wxBitmap& GetBitmapFocus() const { return (wxBitmap&) m_buttonBitmapFocus; }
wxBitmap& GetBitmapDisabled() const { return (wxBitmap&) m_buttonBitmapDisabled; }
inline void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
inline void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
inline void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
void SetBitmapSelected(const wxBitmap& sel) { m_buttonBitmapSelected = sel; };
void SetBitmapFocus(const wxBitmap& focus) { m_buttonBitmapFocus = focus; };
void SetBitmapDisabled(const wxBitmap& disabled) { m_buttonBitmapDisabled = disabled; };
inline void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
inline int GetMarginX(void) { return m_marginX; }
inline int GetMarginY(void) { return m_marginY; }
void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
int GetMarginX() const { return m_marginX; }
int GetMarginY() const { return m_marginY; }
// Implementation
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 );
// 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:
wxBitmap m_buttonBitmap;
wxBitmap m_buttonBitmapSelected;
wxBitmap m_buttonBitmapFocus;
wxBitmap m_buttonBitmapDisabled;
int m_marginX;
int m_marginY;
protected:
wxBitmap m_buttonBitmap;
wxBitmap m_buttonBitmapSelected;
wxBitmap m_buttonBitmapFocus;
wxBitmap m_buttonBitmapDisabled;
int m_marginX;
int m_marginY;
};
#endif

7
include/wx/msw/spinbutt.h
View File

@ -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);
};

21
include/wx/spinbutt.h
View File

@ -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_DOWN(id, func) { wxEVT_SCROLL_LINEDOWN, 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(id, 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 },
#define EVT_SPIN(id, func) { wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func },
#endif // wxUSE_SPINBTN

3
src/common/image.cpp
View File

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

439
src/generic/progdlgg.cpp
View File

@ -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,184 +43,212 @@
#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)
EVT_BUTTON(-1, wxProgressDialog::OnCancel)
BEGIN_EVENT_TABLE(wxProgressDialog, wxDialog)
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)
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;
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;
wxLayoutConstraints *c;
wxFrame::Create(m_parent, -1, title, wxDefaultPosition,
wxDefaultSize, wxDEFAULT_DIALOG_STYLE);
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
wxClientDC dc(this);
dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
long widthText;
dc.GetTextExtent(message, &widthText, NULL);
wxLayoutConstraints *c;
m_msg = new wxStaticText(this, -1, message);
c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 2*LAYOUT_X_MARGIN);
c->top.SameAs(this, wxTop, 2*LAYOUT_Y_MARGIN);
c->width.AsIs();
c->height.AsIs();
m_msg->SetConstraints(c);
wxClientDC dc(this);
dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
long widthText;
dc.GetTextExtent(message, &widthText, NULL);
wxSize sizeDlg, sizeLabel = m_msg->GetSize();
sizeDlg.y = 2*LAYOUT_Y_MARGIN + sizeLabel.y;
m_msg = new wxStaticText(this, -1, message);
c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 2*LAYOUT_X_MARGIN);
c->top.SameAs(this, wxTop, 2*LAYOUT_Y_MARGIN);
c->width.AsIs();
c->height.AsIs();
m_msg->SetConstraints(c);
lastWindow = m_msg;
wxWindow *lastWindow = m_msg;
if ( maximum > 0 )
{
m_gauge = new wxGauge(this, -1, maximum,
wxDefaultPosition, wxDefaultSize,
wxGA_HORIZONTAL | wxRAISED_BORDER);
c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 2*LAYOUT_X_MARGIN);
c->top.Below(m_msg, 2*LAYOUT_Y_MARGIN);
c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
c->height.AsIs();
m_gauge->SetConstraints(c);
m_gauge->SetValue(0);
lastWindow = m_gauge;
}
else
m_gauge = (wxGauge *)NULL;
if ( maximum > 0 )
{
m_gauge = new wxGauge(this, -1, maximum,
wxDefaultPosition, wxDefaultSize,
wxGA_HORIZONTAL | wxRAISED_BORDER);
c = new wxLayoutConstraints;
c->left.SameAs(this, wxLeft, 2*LAYOUT_X_MARGIN);
c->top.Below(m_msg, 2*LAYOUT_Y_MARGIN);
c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN);
c->height.AsIs();
m_gauge->SetConstraints(c);
m_gauge->SetValue(0);
lastWindow = m_gauge;
if ( style & wxPD_ELAPSED_TIME )
{
m_elapsed = new wxStaticText(this, -1, "");
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);
wxSize sizeGauge = m_gauge->GetSize();
sizeDlg.y += 2*LAYOUT_Y_MARGIN + sizeGauge.y;
}
else
m_gauge = (wxGauge *)NULL;
wxStaticText *dummy = new wxStaticText(this, -1, _T("Elapsed time : "));
c = new wxLayoutConstraints;
c->right.LeftOf(m_elapsed);
c->top.SameAs(m_elapsed, wxTop, 0);
c->width.AsIs();
c->height.AsIs();
dummy->SetConstraints(c);
// create the estimated/remaining/total time zones if requested
m_elapsed = m_estimated = m_remaining = NULL;
lastWindow = m_elapsed;
}
int nTimeLabels = 0;
if ( style & wxPD_ELAPSED_TIME )
{
nTimeLabels++;
if ( style & wxPD_ESTIMATED_TIME )
{
m_estimated = new wxStaticText(this, -1, "");
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);
m_elapsed = CreateLabel(_T("Elapsed time : "), &lastWindow);
}
wxStaticText *dummy = new wxStaticText(this, -1, _T("Estimated time : "));
c = new wxLayoutConstraints;
c->right.LeftOf(m_estimated);
c->top.SameAs(m_estimated, wxTop, 0);
c->width.AsIs();
c->height.AsIs();
dummy->SetConstraints(c);
if ( style & wxPD_ESTIMATED_TIME )
{
nTimeLabels++;
lastWindow = m_estimated;
}
m_estimated = CreateLabel(_T("Estimated time : "), &lastWindow);
}
if ( style & wxPD_REMAINING_TIME )
{
m_remaining = new wxStaticText(this, -1, "");
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);
if ( style & wxPD_REMAINING_TIME )
{
nTimeLabels++;
wxStaticText *dummy = new wxStaticText(this, -1, _T("Remaining time : "));
c = new wxLayoutConstraints;
c->right.LeftOf(m_remaining);
c->top.SameAs(m_remaining, wxTop, 0);
c->width.AsIs();
c->height.AsIs();
dummy->SetConstraints(c);
m_remaining = CreateLabel(_T("Remaining time : "), &lastWindow);
}
lastWindow = m_remaining;
}
if ( nTimeLabels > 0 )
{
// set it to the current time
m_timeStart = wxGetCurrentTime();
if ( hasAbortButton )
{
m_btnAbort = new wxButton(this, -1, _("Cancel"));
c = new wxLayoutConstraints;
c->centreX.SameAs(this, wxCentreX);
c->top.Below(lastWindow, 2*LAYOUT_Y_MARGIN);
c->width.AsIs();
c->height.AsIs();
m_btnAbort->SetConstraints(c);
}
else
m_btnAbort = (wxButton *)NULL;
sizeDlg.y += nTimeLabels * (sizeLabel.y + LAYOUT_Y_MARGIN);
}
SetAutoLayout(TRUE);
Layout();
if ( hasAbortButton )
{
m_btnAbort = new wxButton(this, wxID_CANCEL, _("Cancel"));
c = new wxLayoutConstraints;
// calc the height of the dialog
Fit();
// and set the width from it - unfortunately, Fit() makes the dialog way too
// wide under Windows, so try to find a reasonable value for the width, not
// too big and not too small
wxSize size = GetClientSize();
size.x = wxMax(3*widthText/2, 2*size.y);
SetClientSize(size);
// 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);
#endif // MSW/!MSW
c->bottom.SameAs(this, wxBottom, 2*LAYOUT_Y_MARGIN);
Show(TRUE);
Centre(wxCENTER_FRAME | wxBOTH);
wxSize sizeBtn = wxButton::GetDefaultSize();
c->width.Absolute(sizeBtn.x);
c->height.Absolute(sizeBtn.y);
if(m_disableParentOnly)
{
if(m_parent) m_parent->Enable(FALSE);
}
else
wxEnableTopLevelWindows(FALSE);
m_btnAbort->SetConstraints(c);
Enable(TRUE); // enable this window
wxYield();
sizeDlg.y += 2*LAYOUT_Y_MARGIN + sizeBtn.y;
}
else
m_btnAbort = (wxButton *)NULL;
SetAutoLayout(TRUE);
Layout();
sizeDlg.y += 2*LAYOUT_Y_MARGIN;
// try to make the dialog not square but rectangular of reasonabel width
sizeDlg.x = wxMax(widthText, 4*sizeDlg.y/3);
sizeDlg.x *= 3;
sizeDlg.x /= 2;
SetClientSize(sizeDlg);
Centre(wxCENTER_FRAME | wxBOTH);
if (m_disableParentOnly )
{
if ( m_parent )
m_parent->Enable(FALSE);
}
else
{
wxEnableTopLevelWindows(FALSE);
}
Show(TRUE);
Enable(TRUE); // enable this window
}
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;
wxTime diff = timenow - *m_time;
unsigned long secs = diff.GetSecond() + 60 * diff.GetMinute() + 60 * 60 * diff.GetHour();
unsigned long estim = secs * m_maximum / value;
unsigned long remai = estim - secs;
wxString s;
unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
unsigned long estimated = elapsed * m_maximum / value;
unsigned long remaining = estimated - elapsed;
if (m_elapsed)
{
s.Printf(_T("%i:%02i:%02i"), diff.GetHour(), diff.GetMinute(), diff.GetSecond());
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);
}
SetTimeLabel(elapsed, m_elapsed);
SetTimeLabel(estimated, m_estimated);
SetTimeLabel(remaining, m_remaining);
}
if ( (value == m_maximum - 1) && !(GetWindowStyleFlag() & wxPD_AUTO_HIDE) )
@ -259,43 +282,91 @@ 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 )
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();
}
wxYield();
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 )
event.Veto(TRUE);
else
m_state = Canceled;
if ( m_state == Uncancelable )
event.Veto(TRUE);
else
m_state = Canceled;
}
// ----------------------------------------------------------------------------
// destruction
// ----------------------------------------------------------------------------
wxProgressDialog::~wxProgressDialog()
{
if ( m_disableParentOnly )
{
if(m_parent) m_parent->Enable(TRUE);
}
else
wxEnableTopLevelWindows(TRUE);
if (m_time) delete m_time;
if ( m_disableParentOnly )
{
if ( m_parent )
m_parent->Enable(TRUE);
}
else
{
wxEnableTopLevelWindows(TRUE);
}
}
#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

1
src/gtk/spinbutt.cpp
View File

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

1
src/gtk1/spinbutt.cpp
View File

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

4
src/msw/bmpbuttn.cpp
View File

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

4
src/msw/button.cpp
View File

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

6
src/msw/frame.cpp
View File

@ -175,8 +175,10 @@ void wxFrame::DoGetClientSize(int *x, int *y) const
rect.bottom -= pt.y;
rect.right -= pt.x;
*x = rect.right;
*y = rect.bottom;
if ( x )
*x = rect.right;
if ( y )
*y = rect.bottom;
}
// Set the client size (i.e. leave the calculation of borders etc.

12
src/msw/mdi.cpp
View File

@ -192,10 +192,8 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
if (style & wxCAPTION)
msflags |= WS_CAPTION;
// Adding WS_CLIPCHILDREN causes children not to be properly
// drawn when first displaying them.
// if (style & wxCLIP_CHILDREN)
// 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
// must pass it to DefFrameProc() too
MSWDefWindowProc(message, wParam, lParam);
// as we don't (usually) resize the MDI client to exactly fit the
// client area (we put it below the toolbar, above statusbar &c),
// we should not pass this one to DefFrameProc
break;
}

66
src/msw/spinbutt.cpp
View File

@ -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 )
return FALSE;
wxCHECK_MSG( control, FALSE, _T("scrolling what?") )
wxSpinEvent event(wxEVT_NULL, m_windowId);
event.SetPosition(pos);
event.SetOrientation(orientation);
event.SetEventObject(this);
switch ( wParam )
if ( wParam != SB_THUMBPOSITION )
{
case SB_TOP:
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;
// probable SB_ENDSCROLL - we don't react to it
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

28
src/msw/window.cpp
View File

@ -1115,12 +1115,9 @@ 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;
}
wxPoint pt(parent->GetClientAreaOrigin());
point.x -= pt.x;
point.y -= pt.y;
}
if ( x )
@ -1372,10 +1369,14 @@ void wxWindow::GetTextExtent(const wxString& string,
ReleaseDC(hWnd, dc);
if ( x ) *x = sizeRect.cx;
if ( y ) *y = sizeRect.cy;
if ( descent ) *descent = tm.tmDescent;
if ( externalLeading ) *externalLeading = tm.tmExternalLeading;
if ( x )
*x = sizeRect.cx;
if ( y )
*y = sizeRect.cy;
if ( descent )
*descent = tm.tmDescent;
if ( externalLeading )
*externalLeading = tm.tmExternalLeading;
}
#if wxUSE_CARET && WXWIN_COMPATIBILITY
@ -3319,8 +3320,11 @@ void wxGetCharSize(WXHWND wnd, int *x, int *y,wxFont *the_font)
SelectObject(dc,was);
}
ReleaseDC((HWND)wnd, dc);
*x = tm.tmAveCharWidth;
*y = tm.tmHeight + tm.tmExternalLeading;
if ( x )
*x = tm.tmAveCharWidth;
if ( y )
*y = tm.tmHeight + tm.tmExternalLeading;
// if ( the_font )
// the_font->ReleaseResource();