[wxWidgets.git] / samples / widgets / gauge.cpp

/////////////////////////////////////////////////////////////////////////////
// Program:     wxWidgets Widgets Sample
// Name:        gauge.cpp
// Purpose:     Part of the widgets sample showing wxGauge
// Author:      Vadim Zeitlin
// Created:     27.03.01
// Id:          $Id$
// Copyright:   (c) 2001 Vadim Zeitlin
// License:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// for compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers
#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/timer.h"

    #include "wx/bitmap.h"
    #include "wx/button.h"
    #include "wx/checkbox.h"
    #include "wx/combobox.h"
    #include "wx/gauge.h"
    #include "wx/radiobox.h"
    #include "wx/statbox.h"
    #include "wx/textctrl.h"
#endif

#include "wx/sizer.h"

#include "widgets.h"
#if wxUSE_GAUGE
#include "icons/gauge.xpm"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// control ids
enum
{
    GaugePage_Reset = wxID_HIGHEST,
    GaugePage_Progress,
    GaugePage_IndeterminateProgress,
    GaugePage_Clear,
    GaugePage_SetValue,
    GaugePage_SetRange,
    GaugePage_CurValueText,
    GaugePage_ValueText,
    GaugePage_RangeText,
    GaugePage_Timer,
    GaugePage_IndeterminateTimer,
    GaugePage_Gauge
};

// ----------------------------------------------------------------------------
// GaugeWidgetsPage
// ----------------------------------------------------------------------------

class GaugeWidgetsPage : public WidgetsPage
{
public:
    GaugeWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist);
    virtual ~GaugeWidgetsPage();

    virtual wxControl *GetWidget() const { return m_gauge; }
    virtual void RecreateWidget() { CreateGauge(); }

    // lazy creation of the content
    virtual void CreateContent();

protected:
    // event handlers
    void OnButtonReset(wxCommandEvent& event);
    void OnButtonProgress(wxCommandEvent& event);
    void OnButtonIndeterminateProgress(wxCommandEvent& event);
    void OnButtonClear(wxCommandEvent& event);
    void OnButtonSetValue(wxCommandEvent& event);
    void OnButtonSetRange(wxCommandEvent& event);

    void OnCheckOrRadioBox(wxCommandEvent& event);

    void OnUpdateUIValueButton(wxUpdateUIEvent& event);
    void OnUpdateUIRangeButton(wxUpdateUIEvent& event);
    void OnUpdateUIResetButton(wxUpdateUIEvent& event);

    void OnUpdateUICurValueText(wxUpdateUIEvent& event);

    void OnProgressTimer(wxTimerEvent& event);
    void OnIndeterminateProgressTimer(wxTimerEvent& event);

    // reset the gauge parameters
    void Reset();

    // (re)create the gauge
    void CreateGauge();

    // start progress timer
    void StartTimer(wxButton*);

    // stop the progress timer
    void StopTimer(wxButton*);

    // the gauge range
    unsigned long m_range;

    // the controls
    // ------------

    // the checkboxes for styles
    wxCheckBox *m_chkVert,
               *m_chkSmooth;

    // the gauge itself and the sizer it is in
    wxGauge *m_gauge;
    wxSizer *m_sizerGauge;

    // the text entries for set value/range
    wxTextCtrl *m_textValue,
               *m_textRange;

    // the timer for simulating gauge progress
    wxTimer *m_timer;

private:
    DECLARE_EVENT_TABLE()
    DECLARE_WIDGETS_PAGE(GaugeWidgetsPage)
};

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(GaugeWidgetsPage, WidgetsPage)
    EVT_BUTTON(GaugePage_Reset, GaugeWidgetsPage::OnButtonReset)
    EVT_BUTTON(GaugePage_Progress, GaugeWidgetsPage::OnButtonProgress)
    EVT_BUTTON(GaugePage_IndeterminateProgress, GaugeWidgetsPage::OnButtonIndeterminateProgress)
    EVT_BUTTON(GaugePage_Clear, GaugeWidgetsPage::OnButtonClear)
    EVT_BUTTON(GaugePage_SetValue, GaugeWidgetsPage::OnButtonSetValue)
    EVT_BUTTON(GaugePage_SetRange, GaugeWidgetsPage::OnButtonSetRange)

    EVT_UPDATE_UI(GaugePage_SetValue, GaugeWidgetsPage::OnUpdateUIValueButton)
    EVT_UPDATE_UI(GaugePage_SetRange, GaugeWidgetsPage::OnUpdateUIRangeButton)
    EVT_UPDATE_UI(GaugePage_Reset, GaugeWidgetsPage::OnUpdateUIResetButton)

    EVT_UPDATE_UI(GaugePage_CurValueText, GaugeWidgetsPage::OnUpdateUICurValueText)

    EVT_CHECKBOX(wxID_ANY, GaugeWidgetsPage::OnCheckOrRadioBox)
    EVT_RADIOBOX(wxID_ANY, GaugeWidgetsPage::OnCheckOrRadioBox)

    EVT_TIMER(GaugePage_Timer, GaugeWidgetsPage::OnProgressTimer)
    EVT_TIMER(GaugePage_IndeterminateTimer, GaugeWidgetsPage::OnIndeterminateProgressTimer)
END_EVENT_TABLE()

// ============================================================================
// implementation
// ============================================================================

#if defined(__WXUNIVERSAL__)
    #define FAMILY_CTRLS UNIVERSAL_CTRLS
#else
    #define FAMILY_CTRLS NATIVE_CTRLS
#endif

IMPLEMENT_WIDGETS_PAGE(GaugeWidgetsPage, _T("Gauge"), FAMILY_CTRLS );

GaugeWidgetsPage::GaugeWidgetsPage(WidgetsBookCtrl *book,
                                   wxImageList *imaglist)
                 :WidgetsPage(book, imaglist, gauge_xpm)
{
    // init everything
    m_range = 100;

    m_timer = (wxTimer *)NULL;

    m_chkVert =
    m_chkSmooth = (wxCheckBox *)NULL;

    m_gauge = (wxGauge *)NULL;
    m_sizerGauge = (wxSizer *)NULL;
}

void GaugeWidgetsPage::CreateContent()
{
    wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);

    // left pane
    wxStaticBox *box = new wxStaticBox(this, wxID_ANY, _T("&Set style"));

    wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);

    m_chkVert = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Vertical"));
    m_chkSmooth = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Smooth"));

    sizerLeft->Add(5, 5, 0, wxGROW | wxALL, 5); // spacer

    wxButton *btn = new wxButton(this, GaugePage_Reset, _T("&Reset"));
    sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 15);

    // middle pane
    wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, _T("&Change gauge value"));
    wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);

    wxTextCtrl *text;
    wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Current value"),
                                                    GaugePage_CurValueText,
                                                    &text);
    text->SetEditable(false);

    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndButton(GaugePage_SetValue,
                                            _T("Set &value"),
                                            GaugePage_ValueText,
                                            &m_textValue);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndButton(GaugePage_SetRange,
                                            _T("Set &range"),
                                            GaugePage_RangeText,
                                            &m_textRange);
    m_textRange->SetValue( wxString::Format(_T("%lu"), m_range) );
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    btn = new wxButton(this, GaugePage_Progress, _T("Simulate &progress"));
    sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);

    btn = new wxButton(this, GaugePage_IndeterminateProgress,
                       _T("Simulate &indeterminate job"));
    sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);

    btn = new wxButton(this, GaugePage_Clear, _T("&Clear"));
    sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);

    // right pane
    wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
    m_gauge = new wxGauge(this, GaugePage_Gauge, m_range);
    sizerRight->Add(m_gauge, 1, wxCENTRE | wxALL, 5);
    sizerRight->SetMinSize(150, 0);
    m_sizerGauge = sizerRight; // save it to modify it later

    // the 3 panes panes compose the window
    sizerTop->Add(sizerLeft, 0, wxGROW | (wxALL & ~wxLEFT), 10);
    sizerTop->Add(sizerMiddle, 1, wxGROW | wxALL, 10);
    sizerTop->Add(sizerRight, 1, wxGROW | (wxALL & ~wxRIGHT), 10);

    // final initializations
    Reset();

    SetSizer(sizerTop);
}

GaugeWidgetsPage::~GaugeWidgetsPage()
{
    delete m_timer;
}

// ----------------------------------------------------------------------------
// operations
// ----------------------------------------------------------------------------

void GaugeWidgetsPage::Reset()
{
    m_chkVert->SetValue(false);
    m_chkSmooth->SetValue(false);
}

void GaugeWidgetsPage::CreateGauge()
{
    int flags = ms_defaultFlags;

    if ( m_chkVert->GetValue() )
        flags |= wxGA_VERTICAL;
    else
        flags |= wxGA_HORIZONTAL;

    if ( m_chkSmooth->GetValue() )
        flags |= wxGA_SMOOTH;

    int val = 0;
    if ( m_gauge )
    {
        val = m_gauge->GetValue();

        m_sizerGauge->Detach( m_gauge );
        delete m_gauge;
    }

    m_gauge = new wxGauge(this, GaugePage_Gauge, m_range,
                          wxDefaultPosition, wxDefaultSize,
                          flags);
    m_gauge->SetValue(val);
    
    if ( flags & wxGA_VERTICAL )
        m_sizerGauge->Add(m_gauge, 0, wxGROW | wxALL, 5);
    else
        m_sizerGauge->Add(m_gauge, 1, wxCENTRE | wxALL, 5);

    m_sizerGauge->Layout();
}

void GaugeWidgetsPage::StartTimer(wxButton *clicked)
{
    static const int INTERVAL = 300;

    wxLogMessage(_T("Launched progress timer (interval = %d ms)"), INTERVAL);

    m_timer = new wxTimer(this,
        clicked->GetId() == GaugePage_Progress ? GaugePage_Timer : GaugePage_IndeterminateTimer);
    m_timer->Start(INTERVAL);

    clicked->SetLabel(_T("&Stop timer"));

    if (clicked->GetId() == GaugePage_Progress)
        FindWindow(GaugePage_IndeterminateProgress)->Disable();
    else
        FindWindow(GaugePage_Progress)->Disable();
}

void GaugeWidgetsPage::StopTimer(wxButton *clicked)
{
    wxCHECK_RET( m_timer, _T("shouldn't be called") );

    m_timer->Stop();
    delete m_timer;
    m_timer = NULL;

    if (clicked->GetId() == GaugePage_Progress)
    {
        clicked->SetLabel(_T("Simulate &progress"));
        FindWindow(GaugePage_IndeterminateProgress)->Enable();
    }
    else
    {
        clicked->SetLabel(_T("Simulate indeterminate job"));
        FindWindow(GaugePage_Progress)->Enable();
    }

    wxLogMessage(_T("Progress finished."));
}

// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------

void GaugeWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
{
    Reset();

    CreateGauge();
}

void GaugeWidgetsPage::OnButtonProgress(wxCommandEvent& event)
{
    wxButton *b = (wxButton *)event.GetEventObject();
    if ( !m_timer )
    {
        StartTimer(b);
    }
    else // stop the running timer
    {
        StopTimer(b);

        wxLogMessage(_T("Stopped the timer."));
    }
}

void GaugeWidgetsPage::OnButtonIndeterminateProgress(wxCommandEvent& event)
{
    wxButton *b = (wxButton *)event.GetEventObject();
    if ( !m_timer )
    {
        StartTimer(b);
    }
    else // stop the running timer
    {
        StopTimer(b);

        wxLogMessage(_T("Stopped the timer."));
    }
}

void GaugeWidgetsPage::OnButtonClear(wxCommandEvent& WXUNUSED(event))
{
    m_gauge->SetValue(0);
}

void GaugeWidgetsPage::OnButtonSetRange(wxCommandEvent& WXUNUSED(event))
{
    unsigned long val;
    if ( !m_textRange->GetValue().ToULong(&val) )
        return;

    m_range = val;
    m_gauge->SetRange(val);
}

void GaugeWidgetsPage::OnButtonSetValue(wxCommandEvent& WXUNUSED(event))
{
    unsigned long val;
    if ( !m_textValue->GetValue().ToULong(&val) )
        return;

    m_gauge->SetValue(val);
}

void GaugeWidgetsPage::OnUpdateUIValueButton(wxUpdateUIEvent& event)
{
    unsigned long val;
    event.Enable( m_textValue->GetValue().ToULong(&val) && (val <= m_range) );
}

void GaugeWidgetsPage::OnUpdateUIRangeButton(wxUpdateUIEvent& event)
{
    unsigned long val;
    event.Enable( m_textRange->GetValue().ToULong(&val) );
}

void GaugeWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
{
    event.Enable( m_chkVert->GetValue() || m_chkSmooth->GetValue() );
}

void GaugeWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
{
    CreateGauge();
}

void GaugeWidgetsPage::OnProgressTimer(wxTimerEvent& WXUNUSED(event))
{
    int val = m_gauge->GetValue();
    if ( (unsigned)val < m_range )
    {
        m_gauge->SetValue(val + 1);
    }
    else // reached the end
    {
        wxButton *btn = (wxButton *)FindWindow(GaugePage_Progress);
        wxCHECK_RET( btn, _T("no progress button?") );

        StopTimer(btn);
    }
}

void GaugeWidgetsPage::OnIndeterminateProgressTimer(wxTimerEvent& WXUNUSED(event))
{
    m_gauge->Pulse();
}

void GaugeWidgetsPage::OnUpdateUICurValueText(wxUpdateUIEvent& event)
{
    event.SetText( wxString::Format(_T("%d"), m_gauge->GetValue()));
}

#endif
    // wxUSE_GAUGE
Commit	Line	Data
32b8ec41	1	/////////////////////////////////////////////////////////////////////////////
be5a51fb	2	// Program: wxWidgets Widgets Sample
32b8ec41 VZ	3	// Name: gauge.cpp
	4	// Purpose: Part of the widgets sample showing wxGauge
	5	// Author: Vadim Zeitlin
	6	// Created: 27.03.01
	7	// Id: $Id$
	8	// Copyright: (c) 2001 Vadim Zeitlin
	9	// License: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// for compilers that support precompilation, includes "wx/wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	// for all others, include the necessary headers
	28	#ifndef WX_PRECOMP
	29	#include "wx/log.h"
	30	#include "wx/timer.h"
	31
3bb70c40	32	#include "wx/bitmap.h"
32b8ec41 VZ	33	#include "wx/button.h"
	34	#include "wx/checkbox.h"
	35	#include "wx/combobox.h"
	36	#include "wx/gauge.h"
	37	#include "wx/radiobox.h"
	38	#include "wx/statbox.h"
	39	#include "wx/textctrl.h"
	40	#endif
	41
	42	#include "wx/sizer.h"
	43
	44	#include "widgets.h"
8dfc2d98	45	#if wxUSE_GAUGE
32b8ec41 VZ	46	#include "icons/gauge.xpm"
	47
	48	// ----------------------------------------------------------------------------
	49	// constants
	50	// ----------------------------------------------------------------------------
	51
	52	// control ids
	53	enum
	54	{
f0fa4312	55	GaugePage_Reset = wxID_HIGHEST,
32b8ec41	56	GaugePage_Progress,
5c35d5c1	57	GaugePage_IndeterminateProgress,
32b8ec41 VZ	58	GaugePage_Clear,
	59	GaugePage_SetValue,
	60	GaugePage_SetRange,
	61	GaugePage_CurValueText,
	62	GaugePage_ValueText,
	63	GaugePage_RangeText,
	64	GaugePage_Timer,
5c35d5c1	65	GaugePage_IndeterminateTimer,
32b8ec41 VZ	66	GaugePage_Gauge
	67	};
	68
	69	// ----------------------------------------------------------------------------
	70	// GaugeWidgetsPage
	71	// ----------------------------------------------------------------------------
	72
	73	class GaugeWidgetsPage : public WidgetsPage
	74	{
	75	public:
f2fdc4d5	76	GaugeWidgetsPage(WidgetsBookCtrl book, wxImageList imaglist);
32b8ec41 VZ	77	virtual ~GaugeWidgetsPage();
32b8ec41 VZ	78
195df7a7	79	virtual wxControl *GetWidget() const { return m_gauge; }
1301e228	80	virtual void RecreateWidget() { CreateGauge(); }
195df7a7	81
453535a7 WS	82	// lazy creation of the content
	83	virtual void CreateContent();
	84
32b8ec41 VZ	85	protected:
	86	// event handlers
	87	void OnButtonReset(wxCommandEvent& event);
	88	void OnButtonProgress(wxCommandEvent& event);
5c35d5c1	89	void OnButtonIndeterminateProgress(wxCommandEvent& event);
32b8ec41 VZ	90	void OnButtonClear(wxCommandEvent& event);
	91	void OnButtonSetValue(wxCommandEvent& event);
	92	void OnButtonSetRange(wxCommandEvent& event);
	93
	94	void OnCheckOrRadioBox(wxCommandEvent& event);
	95
	96	void OnUpdateUIValueButton(wxUpdateUIEvent& event);
	97	void OnUpdateUIRangeButton(wxUpdateUIEvent& event);
	98	void OnUpdateUIResetButton(wxUpdateUIEvent& event);
	99
	100	void OnUpdateUICurValueText(wxUpdateUIEvent& event);
	101
	102	void OnProgressTimer(wxTimerEvent& event);
5c35d5c1	103	void OnIndeterminateProgressTimer(wxTimerEvent& event);
32b8ec41 VZ	104
	105	// reset the gauge parameters
	106	void Reset();
	107
	108	// (re)create the gauge
	109	void CreateGauge();
	110
5c35d5c1 VZ	111	// start progress timer
	112	void StartTimer(wxButton*);
	113
32b8ec41	114	// stop the progress timer
5c35d5c1	115	void StopTimer(wxButton*);
32b8ec41 VZ	116
	117	// the gauge range
	118	unsigned long m_range;
	119
	120	// the controls
	121	// ------------
	122
	123	// the checkboxes for styles
	124	wxCheckBox *m_chkVert,
5c35d5c1	125	*m_chkSmooth;
32b8ec41 VZ	126
	127	// the gauge itself and the sizer it is in
	128	wxGauge *m_gauge;
	129	wxSizer *m_sizerGauge;
	130
	131	// the text entries for set value/range
	132	wxTextCtrl *m_textValue,
	133	*m_textRange;
	134
	135	// the timer for simulating gauge progress
	136	wxTimer *m_timer;
	137
	138	private:
5e173f35 GD	139	DECLARE_EVENT_TABLE()
5e173f35 GD	140	DECLARE_WIDGETS_PAGE(GaugeWidgetsPage)
32b8ec41 VZ	141	};
	142
	143	// ----------------------------------------------------------------------------
	144	// event tables
	145	// ----------------------------------------------------------------------------
	146
	147	BEGIN_EVENT_TABLE(GaugeWidgetsPage, WidgetsPage)
	148	EVT_BUTTON(GaugePage_Reset, GaugeWidgetsPage::OnButtonReset)
	149	EVT_BUTTON(GaugePage_Progress, GaugeWidgetsPage::OnButtonProgress)
5c35d5c1	150	EVT_BUTTON(GaugePage_IndeterminateProgress, GaugeWidgetsPage::OnButtonIndeterminateProgress)
32b8ec41 VZ	151	EVT_BUTTON(GaugePage_Clear, GaugeWidgetsPage::OnButtonClear)
	152	EVT_BUTTON(GaugePage_SetValue, GaugeWidgetsPage::OnButtonSetValue)
	153	EVT_BUTTON(GaugePage_SetRange, GaugeWidgetsPage::OnButtonSetRange)
	154
	155	EVT_UPDATE_UI(GaugePage_SetValue, GaugeWidgetsPage::OnUpdateUIValueButton)
	156	EVT_UPDATE_UI(GaugePage_SetRange, GaugeWidgetsPage::OnUpdateUIRangeButton)
	157	EVT_UPDATE_UI(GaugePage_Reset, GaugeWidgetsPage::OnUpdateUIResetButton)
	158
	159	EVT_UPDATE_UI(GaugePage_CurValueText, GaugeWidgetsPage::OnUpdateUICurValueText)
	160
206d3a16 JS	161	EVT_CHECKBOX(wxID_ANY, GaugeWidgetsPage::OnCheckOrRadioBox)
206d3a16 JS	162	EVT_RADIOBOX(wxID_ANY, GaugeWidgetsPage::OnCheckOrRadioBox)
32b8ec41 VZ	163
32b8ec41 VZ	164	EVT_TIMER(GaugePage_Timer, GaugeWidgetsPage::OnProgressTimer)
5c35d5c1	165	EVT_TIMER(GaugePage_IndeterminateTimer, GaugeWidgetsPage::OnIndeterminateProgressTimer)
32b8ec41 VZ	166	END_EVENT_TABLE()
	167
	168	// ============================================================================
	169	// implementation
	170	// ============================================================================
	171
f0fa4312 WS	172	#if defined(__WXUNIVERSAL__)
	173	#define FAMILY_CTRLS UNIVERSAL_CTRLS
	174	#else
	175	#define FAMILY_CTRLS NATIVE_CTRLS
	176	#endif
	177
	178	IMPLEMENT_WIDGETS_PAGE(GaugeWidgetsPage, _T("Gauge"), FAMILY_CTRLS );
32b8ec41	179
f2fdc4d5	180	GaugeWidgetsPage::GaugeWidgetsPage(WidgetsBookCtrl *book,
61c083e7	181	wxImageList *imaglist)
261357eb	182	:WidgetsPage(book, imaglist, gauge_xpm)
32b8ec41	183	{
32b8ec41 VZ	184	// init everything
	185	m_range = 100;
	186
	187	m_timer = (wxTimer *)NULL;
	188
	189	m_chkVert =
5c35d5c1	190	m_chkSmooth = (wxCheckBox *)NULL;
32b8ec41 VZ	191
	192	m_gauge = (wxGauge *)NULL;
	193	m_sizerGauge = (wxSizer *)NULL;
453535a7	194	}
32b8ec41	195
453535a7 WS	196	void GaugeWidgetsPage::CreateContent()
453535a7 WS	197	{
32b8ec41 VZ	198	wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
	199
	200	// left pane
206d3a16	201	wxStaticBox *box = new wxStaticBox(this, wxID_ANY, _T("&Set style"));
32b8ec41 VZ	202
	203	wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);
	204
	205	m_chkVert = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Vertical"));
	206	m_chkSmooth = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Smooth"));
	207
	208	sizerLeft->Add(5, 5, 0, wxGROW \| wxALL, 5); // spacer
	209
	210	wxButton *btn = new wxButton(this, GaugePage_Reset, _T("&Reset"));
	211	sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL \| wxALL, 15);
	212
	213	// middle pane
c6ba246b	214	wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, _T("&Change gauge value"));
32b8ec41 VZ	215	wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
	216
	217	wxTextCtrl *text;
	218	wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Current value"),
	219	GaugePage_CurValueText,
	220	&text);
206d3a16	221	text->SetEditable(false);
32b8ec41 VZ	222
	223	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
	224
	225	sizerRow = CreateSizerWithTextAndButton(GaugePage_SetValue,
	226	_T("Set &value"),
	227	GaugePage_ValueText,
	228	&m_textValue);
	229	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
	230
	231	sizerRow = CreateSizerWithTextAndButton(GaugePage_SetRange,
	232	_T("Set &range"),
	233	GaugePage_RangeText,
	234	&m_textRange);
aec18ff7	235	m_textRange->SetValue( wxString::Format(_T("%lu"), m_range) );
32b8ec41 VZ	236	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
	237
	238	btn = new wxButton(this, GaugePage_Progress, _T("Simulate &progress"));
	239	sizerMiddle->Add(btn, 0, wxALL \| wxGROW, 5);
	240
c6ba246b VZ	241	btn = new wxButton(this, GaugePage_IndeterminateProgress,
c6ba246b VZ	242	_T("Simulate &indeterminate job"));
5c35d5c1 VZ	243	sizerMiddle->Add(btn, 0, wxALL \| wxGROW, 5);
5c35d5c1 VZ	244
32b8ec41 VZ	245	btn = new wxButton(this, GaugePage_Clear, _T("&Clear"));
	246	sizerMiddle->Add(btn, 0, wxALL \| wxGROW, 5);
	247
	248	// right pane
	249	wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
	250	m_gauge = new wxGauge(this, GaugePage_Gauge, m_range);
	251	sizerRight->Add(m_gauge, 1, wxCENTRE \| wxALL, 5);
7b127900	252	sizerRight->SetMinSize(150, 0);
32b8ec41 VZ	253	m_sizerGauge = sizerRight; // save it to modify it later
	254
	255	// the 3 panes panes compose the window
	256	sizerTop->Add(sizerLeft, 0, wxGROW \| (wxALL & ~wxLEFT), 10);
	257	sizerTop->Add(sizerMiddle, 1, wxGROW \| wxALL, 10);
	258	sizerTop->Add(sizerRight, 1, wxGROW \| (wxALL & ~wxRIGHT), 10);
	259
	260	// final initializations
	261	Reset();
	262
32b8ec41	263	SetSizer(sizerTop);
32b8ec41 VZ	264	}
	265
	266	GaugeWidgetsPage::~GaugeWidgetsPage()
	267	{
	268	delete m_timer;
	269	}
	270
	271	// ----------------------------------------------------------------------------
	272	// operations
	273	// ----------------------------------------------------------------------------
	274
	275	void GaugeWidgetsPage::Reset()
	276	{
206d3a16 JS	277	m_chkVert->SetValue(false);
206d3a16 JS	278	m_chkSmooth->SetValue(false);
32b8ec41 VZ	279	}
	280
	281	void GaugeWidgetsPage::CreateGauge()
	282	{
1301e228	283	int flags = ms_defaultFlags;
32b8ec41 VZ	284
	285	if ( m_chkVert->GetValue() )
	286	flags \|= wxGA_VERTICAL;
	287	else
	288	flags \|= wxGA_HORIZONTAL;
	289
	290	if ( m_chkSmooth->GetValue() )
	291	flags \|= wxGA_SMOOTH;
	292
	293	int val = 0;
	294	if ( m_gauge )
	295	{
	296	val = m_gauge->GetValue();
	297
12a3f227	298	m_sizerGauge->Detach( m_gauge );
32b8ec41 VZ	299	delete m_gauge;
	300	}
	301
	302	m_gauge = new wxGauge(this, GaugePage_Gauge, m_range,
	303	wxDefaultPosition, wxDefaultSize,
	304	flags);
	305	m_gauge->SetValue(val);
ef78ec37	306
32b8ec41 VZ	307	if ( flags & wxGA_VERTICAL )
	308	m_sizerGauge->Add(m_gauge, 0, wxGROW \| wxALL, 5);
	309	else
	310	m_sizerGauge->Add(m_gauge, 1, wxCENTRE \| wxALL, 5);
	311
	312	m_sizerGauge->Layout();
	313	}
	314
5c35d5c1 VZ	315	void GaugeWidgetsPage::StartTimer(wxButton *clicked)
	316	{
	317	static const int INTERVAL = 300;
	318
	319	wxLogMessage(_T("Launched progress timer (interval = %d ms)"), INTERVAL);
	320
	321	m_timer = new wxTimer(this,
	322	clicked->GetId() == GaugePage_Progress ? GaugePage_Timer : GaugePage_IndeterminateTimer);
	323	m_timer->Start(INTERVAL);
	324
	325	clicked->SetLabel(_T("&Stop timer"));
	326
	327	if (clicked->GetId() == GaugePage_Progress)
	328	FindWindow(GaugePage_IndeterminateProgress)->Disable();
	329	else
	330	FindWindow(GaugePage_Progress)->Disable();
	331	}
	332
	333	void GaugeWidgetsPage::StopTimer(wxButton *clicked)
	334	{
	335	wxCHECK_RET( m_timer, _T("shouldn't be called") );
	336
	337	m_timer->Stop();
	338	delete m_timer;
	339	m_timer = NULL;
	340
	341	if (clicked->GetId() == GaugePage_Progress)
	342	{
	343	clicked->SetLabel(_T("Simulate &progress"));
	344	FindWindow(GaugePage_IndeterminateProgress)->Enable();
	345	}
	346	else
	347	{
c6ba246b	348	clicked->SetLabel(_T("Simulate indeterminate job"));
5c35d5c1 VZ	349	FindWindow(GaugePage_Progress)->Enable();
	350	}
	351
	352	wxLogMessage(_T("Progress finished."));
	353	}
	354
32b8ec41 VZ	355	// ----------------------------------------------------------------------------
	356	// event handlers
	357	// ----------------------------------------------------------------------------
	358
	359	void GaugeWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
	360	{
	361	Reset();
	362
	363	CreateGauge();
	364	}
	365
	366	void GaugeWidgetsPage::OnButtonProgress(wxCommandEvent& event)
	367	{
5c35d5c1	368	wxButton b = (wxButton )event.GetEventObject();
32b8ec41 VZ	369	if ( !m_timer )
32b8ec41 VZ	370	{
5c35d5c1 VZ	371	StartTimer(b);
	372	}
	373	else // stop the running timer
	374	{
	375	StopTimer(b);
32b8ec41	376
5c35d5c1 VZ	377	wxLogMessage(_T("Stopped the timer."));
	378	}
	379	}
32b8ec41	380
5c35d5c1 VZ	381	void GaugeWidgetsPage::OnButtonIndeterminateProgress(wxCommandEvent& event)
	382	{
	383	wxButton b = (wxButton )event.GetEventObject();
	384	if ( !m_timer )
	385	{
	386	StartTimer(b);
32b8ec41 VZ	387	}
	388	else // stop the running timer
	389	{
5c35d5c1	390	StopTimer(b);
32b8ec41 VZ	391
	392	wxLogMessage(_T("Stopped the timer."));
	393	}
	394	}
	395
	396	void GaugeWidgetsPage::OnButtonClear(wxCommandEvent& WXUNUSED(event))
	397	{
	398	m_gauge->SetValue(0);
	399	}
	400
	401	void GaugeWidgetsPage::OnButtonSetRange(wxCommandEvent& WXUNUSED(event))
	402	{
	403	unsigned long val;
	404	if ( !m_textRange->GetValue().ToULong(&val) )
	405	return;
	406
efb349e4	407	m_range = val;
32b8ec41 VZ	408	m_gauge->SetRange(val);
	409	}
	410
	411	void GaugeWidgetsPage::OnButtonSetValue(wxCommandEvent& WXUNUSED(event))
	412	{
	413	unsigned long val;
	414	if ( !m_textValue->GetValue().ToULong(&val) )
	415	return;
	416
	417	m_gauge->SetValue(val);
	418	}
	419
	420	void GaugeWidgetsPage::OnUpdateUIValueButton(wxUpdateUIEvent& event)
	421	{
	422	unsigned long val;
	423	event.Enable( m_textValue->GetValue().ToULong(&val) && (val <= m_range) );
	424	}
	425
	426	void GaugeWidgetsPage::OnUpdateUIRangeButton(wxUpdateUIEvent& event)
	427	{
	428	unsigned long val;
	429	event.Enable( m_textRange->GetValue().ToULong(&val) );
	430	}
	431
	432	void GaugeWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
	433	{
	434	event.Enable( m_chkVert->GetValue() \|\| m_chkSmooth->GetValue() );
	435	}
	436
c02e5a31	437	void GaugeWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
32b8ec41 VZ	438	{
	439	CreateGauge();
	440	}
	441
	442	void GaugeWidgetsPage::OnProgressTimer(wxTimerEvent& WXUNUSED(event))
	443	{
	444	int val = m_gauge->GetValue();
	445	if ( (unsigned)val < m_range )
	446	{
	447	m_gauge->SetValue(val + 1);
	448	}
	449	else // reached the end
	450	{
5c35d5c1 VZ	451	wxButton btn = (wxButton )FindWindow(GaugePage_Progress);
	452	wxCHECK_RET( btn, _T("no progress button?") );
	453
	454	StopTimer(btn);
32b8ec41 VZ	455	}
	456	}
	457
5c35d5c1	458	void GaugeWidgetsPage::OnIndeterminateProgressTimer(wxTimerEvent& WXUNUSED(event))
32b8ec41	459	{
5c35d5c1	460	m_gauge->Pulse();
32b8ec41 VZ	461	}
32b8ec41 VZ	462
5c35d5c1	463	void GaugeWidgetsPage::OnUpdateUICurValueText(wxUpdateUIEvent& event)
32b8ec41	464	{
5c35d5c1	465	event.SetText( wxString::Format(_T("%d"), m_gauge->GetValue()));
32b8ec41 VZ	466	}
32b8ec41 VZ	467
aec18ff7	468	#endif
8dfc2d98	469	// wxUSE_GAUGE