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

/////////////////////////////////////////////////////////////////////////////
// Program:     wxWidgets Widgets Sample
// Name:        radiobox.cpp
// Purpose:     Part of the widgets sample showing wxRadioBox
// Author:      Vadim Zeitlin
// Created:     15.04.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

#if wxUSE_RADIOBOX

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

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

#include "wx/sizer.h"

#include "widgets.h"

#include "icons/radiobox.xpm"

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

// control ids
enum
{
    RadioPage_Reset = wxID_HIGHEST,
    RadioPage_Update,
    RadioPage_Selection,
    RadioPage_Label,
    RadioPage_LabelBtn,
    RadioPage_EnableItem,
    RadioPage_ShowItem,
    RadioPage_Radio
};

// layout direction radiobox selections
enum
{
    RadioDir_Default,
    RadioDir_LtoR,
    RadioDir_TtoB
};

// default values for the number of radiobox items
static const unsigned int DEFAULT_NUM_ENTRIES = 12;
static const unsigned int DEFAULT_MAJOR_DIM = 3;

// this item is enabled/disabled shown/hidden by the test checkboxes
static const int TEST_BUTTON = 1;

// ----------------------------------------------------------------------------
// RadioWidgetsPage
// ----------------------------------------------------------------------------

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

    virtual wxControl *GetWidget() const { return m_radio; }
    virtual void RecreateWidget() { CreateRadio(); }

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

protected:
    // event handlers
    void OnCheckOrRadioBox(wxCommandEvent& event);
    void OnRadioBox(wxCommandEvent& event);

    void OnButtonReset(wxCommandEvent& event);
    void OnButtonRecreate(wxCommandEvent& event);

    void OnButtonSelection(wxCommandEvent& event);
    void OnButtonSetLabel(wxCommandEvent& event);

    void OnEnableItem(wxCommandEvent& event);
    void OnShowItem(wxCommandEvent& event);

    void OnUpdateUIReset(wxUpdateUIEvent& event);
    void OnUpdateUIUpdate(wxUpdateUIEvent& event);
    void OnUpdateUISelection(wxUpdateUIEvent& event);
    void OnUpdateUIEnableItem(wxUpdateUIEvent& event);
    void OnUpdateUIShowItem(wxUpdateUIEvent& event);

    // reset the wxRadioBox parameters
    void Reset();

    // (re)create the wxRadioBox
    void CreateRadio();

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

    // the check/radio boxes for styles
    wxCheckBox *m_chkVert;
    wxCheckBox *m_chkEnableItem;
    wxCheckBox *m_chkShowItem;
    wxRadioBox *m_radioDir;

    // the gauge itself and the sizer it is in
    wxRadioBox *m_radio;
    wxSizer *m_sizerRadio;

    // the text entries for command parameters
    wxTextCtrl *m_textNumBtns,
               *m_textMajorDim,
               *m_textCurSel,
               *m_textSel,
               *m_textLabel,
               *m_textLabelBtns;

private:
    DECLARE_EVENT_TABLE()
    DECLARE_WIDGETS_PAGE(RadioWidgetsPage)
};

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

BEGIN_EVENT_TABLE(RadioWidgetsPage, WidgetsPage)
    EVT_BUTTON(RadioPage_Reset, RadioWidgetsPage::OnButtonReset)

    EVT_BUTTON(RadioPage_Update, RadioWidgetsPage::OnButtonRecreate)
    EVT_BUTTON(RadioPage_LabelBtn, RadioWidgetsPage::OnButtonRecreate)

    EVT_BUTTON(RadioPage_Selection, RadioWidgetsPage::OnButtonSelection)
    EVT_BUTTON(RadioPage_Label, RadioWidgetsPage::OnButtonSetLabel)

    EVT_UPDATE_UI(RadioPage_Update, RadioWidgetsPage::OnUpdateUIUpdate)
    EVT_UPDATE_UI(RadioPage_Selection, RadioWidgetsPage::OnUpdateUISelection)

    EVT_RADIOBOX(RadioPage_Radio, RadioWidgetsPage::OnRadioBox)

    EVT_CHECKBOX(RadioPage_EnableItem, RadioWidgetsPage::OnEnableItem)
    EVT_CHECKBOX(RadioPage_ShowItem, RadioWidgetsPage::OnShowItem)

    EVT_UPDATE_UI(RadioPage_EnableItem, RadioWidgetsPage::OnUpdateUIEnableItem)
    EVT_UPDATE_UI(RadioPage_ShowItem, RadioWidgetsPage::OnUpdateUIShowItem)

    EVT_CHECKBOX(wxID_ANY, RadioWidgetsPage::OnCheckOrRadioBox)
    EVT_RADIOBOX(wxID_ANY, RadioWidgetsPage::OnCheckOrRadioBox)
END_EVENT_TABLE()

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

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

IMPLEMENT_WIDGETS_PAGE(RadioWidgetsPage, _T("Radio"),
                       FAMILY_CTRLS | WITH_ITEMS_CTRLS
                       );

RadioWidgetsPage::RadioWidgetsPage(WidgetsBookCtrl *book,
                                   wxImageList *imaglist)
                  : WidgetsPage(book, imaglist, radio_xpm)
{
    // init everything
    m_chkVert = (wxCheckBox *)NULL;
    m_chkEnableItem = (wxCheckBox *)NULL;
    m_chkShowItem = (wxCheckBox *)NULL;

    m_textNumBtns =
    m_textLabelBtns =
    m_textLabel = (wxTextCtrl *)NULL;

    m_radio =
    m_radioDir = (wxRadioBox *)NULL;
    m_sizerRadio = (wxSizer *)NULL;
}

void RadioWidgetsPage::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 layout"));

    static const wxString layoutDir[] =
    {
        _T("default"),
        _T("left to right"),
        _T("top to bottom")
    };

    m_radioDir = new wxRadioBox(this, wxID_ANY, _T("Numbering:"),
                                wxDefaultPosition, wxDefaultSize,
                                WXSIZEOF(layoutDir), layoutDir,
                                1, wxRA_SPECIFY_COLS);
    sizerLeft->Add(m_radioDir, 0, wxGROW | wxALL, 5);

    // if it's not defined, we can't change the radiobox direction
#ifndef wxRA_LEFTTORIGHT
    m_radioDir->Disable();
#endif // wxRA_LEFTTORIGHT

    wxSizer *sizerRow;
    sizerRow = CreateSizerWithTextAndLabel(_T("&Major dimension:"),
                                           wxID_ANY,
                                           &m_textMajorDim);
    sizerLeft->Add(sizerRow, 0, wxGROW | wxALL, 5);

    sizerRow = CreateSizerWithTextAndLabel(_T("&Number of buttons:"),
                                           wxID_ANY,
                                           &m_textNumBtns);
    sizerLeft->Add(sizerRow, 0, wxGROW | wxALL, 5);

    wxButton *btn;
    btn = new wxButton(this, RadioPage_Update, _T("&Update"));
    sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 5);

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

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

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

    sizerRow = CreateSizerWithTextAndLabel(_T("Current selection:"),
                                           wxID_ANY,
                                           &m_textCurSel);
    sizerMiddle->Add(sizerRow, 0, wxGROW | wxALL, 5);

    sizerRow = CreateSizerWithTextAndButton(RadioPage_Selection,
                                            _T("&Change selection:"),
                                           wxID_ANY,
                                           &m_textSel);
    sizerMiddle->Add(sizerRow, 0, wxGROW | wxALL, 5);

    sizerRow = CreateSizerWithTextAndButton(RadioPage_Label,
                                            _T("&Label for box:"),
                                            wxID_ANY,
                                            &m_textLabel);
    sizerMiddle->Add(sizerRow, 0, wxGROW | wxALL, 5);

    sizerRow = CreateSizerWithTextAndButton(RadioPage_LabelBtn,
                                            _T("&Label for buttons:"),
                                            wxID_ANY,
                                            &m_textLabelBtns);
    sizerMiddle->Add(sizerRow, 0, wxGROW | wxALL, 5);

    m_chkEnableItem = CreateCheckBoxAndAddToSizer(sizerMiddle,
                                                  _T("Disable &2nd item"),
                                                  RadioPage_EnableItem);
    m_chkShowItem = CreateCheckBoxAndAddToSizer(sizerMiddle,
                                                _T("Hide 2nd &item"),
                                                RadioPage_ShowItem);

    // right pane
    wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
    sizerRight->SetMinSize(150, 0);
    m_sizerRadio = sizerRight; // save it to modify it later

    Reset();
    CreateRadio();

    // 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, 0, wxGROW | (wxALL & ~wxRIGHT), 10);

    // final initializations
    SetSizer(sizerTop);
}

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

void RadioWidgetsPage::Reset()
{
    m_textMajorDim->SetValue(wxString::Format(_T("%u"), DEFAULT_MAJOR_DIM));
    m_textNumBtns->SetValue(wxString::Format(_T("%u"), DEFAULT_NUM_ENTRIES));
    m_textLabel->SetValue(_T("I'm a radiobox"));
    m_textLabelBtns->SetValue(_T("item"));

    m_chkVert->SetValue(false);
    m_chkEnableItem->SetValue(true);
    m_chkShowItem->SetValue(true);
    m_radioDir->SetSelection(RadioDir_Default);
}

void RadioWidgetsPage::CreateRadio()
{
    int sel;
    if ( m_radio )
    {
        sel = m_radio->GetSelection();

        m_sizerRadio->Detach( m_radio );

        delete m_radio;
    }
    else // first time creation, no old selection to preserve
    {
        sel = -1;
    }

    unsigned long count;
    if ( !m_textNumBtns->GetValue().ToULong(&count) )
    {
        wxLogWarning(_T("Should have a valid number for number of items."));

        // fall back to default
        count = DEFAULT_NUM_ENTRIES;
    }

    unsigned long majorDim;
    if ( !m_textMajorDim->GetValue().ToULong(&majorDim) )
    {
        wxLogWarning(_T("Should have a valid major dimension number."));

        // fall back to default
        majorDim = DEFAULT_MAJOR_DIM;
    }

    wxString *items = new wxString[count];

    wxString labelBtn = m_textLabelBtns->GetValue();
    for ( size_t n = 0; n < count; n++ )
    {
        items[n] = wxString::Format(_T("%s %lu"),
                                    labelBtn.c_str(), (unsigned long)n + 1);
    }

    int flags = m_chkVert->GetValue() ? wxRA_VERTICAL
                                      : wxRA_HORIZONTAL;

    flags |= ms_defaultFlags;

#ifdef wxRA_LEFTTORIGHT
    switch ( m_radioDir->GetSelection() )
    {
        default:
            wxFAIL_MSG( _T("unexpected wxRadioBox layout direction") );
            // fall through

        case RadioDir_Default:
            break;

        case RadioDir_LtoR:
            flags |= wxRA_LEFTTORIGHT;
            break;

        case RadioDir_TtoB:
            flags |= wxRA_TOPTOBOTTOM;
            break;
    }
#endif // wxRA_LEFTTORIGHT

    m_radio = new wxRadioBox(this, RadioPage_Radio,
                             m_textLabel->GetValue(),
                             wxDefaultPosition, wxDefaultSize,
                             count, items,
                             majorDim,
                             flags);

    delete [] items;

    if ( sel >= 0 && (size_t)sel < count )
    {
        m_radio->SetSelection(sel);
    }

    m_sizerRadio->Add(m_radio, 1, wxGROW);
    m_sizerRadio->Layout();

    m_chkEnableItem->SetValue(true);
    m_chkEnableItem->SetValue(true);
}

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

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

    CreateRadio();
}

void RadioWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
{
    CreateRadio();
}

void RadioWidgetsPage::OnRadioBox(wxCommandEvent& event)
{
    int sel = m_radio->GetSelection();
    int event_sel = event.GetSelection();
    wxUnusedVar(event_sel);

    wxLogMessage(_T("Radiobox selection changed, now %d"), sel);

    wxASSERT_MSG( sel == event_sel,
                  _T("selection should be the same in event and radiobox") );

    m_textCurSel->SetValue(wxString::Format(_T("%d"), sel));
}

void RadioWidgetsPage::OnButtonRecreate(wxCommandEvent& WXUNUSED(event))
{
    CreateRadio();
}

void RadioWidgetsPage::OnButtonSetLabel(wxCommandEvent& WXUNUSED(event))
{
    m_radio->wxControl::SetLabel(m_textLabel->GetValue());
}

void RadioWidgetsPage::OnButtonSelection(wxCommandEvent& WXUNUSED(event))
{
    unsigned long sel;
    if ( !m_textSel->GetValue().ToULong(&sel) ||
            (sel >= (size_t)m_radio->GetCount()) )
    {
        wxLogWarning(_T("Invalid number specified as new selection."));
    }
    else
    {
        m_radio->SetSelection(sel);
    }
}

void RadioWidgetsPage::OnEnableItem(wxCommandEvent& event)
{
    m_radio->Enable(TEST_BUTTON, event.IsChecked());
}

void RadioWidgetsPage::OnShowItem(wxCommandEvent& event)
{
    m_radio->Show(TEST_BUTTON, event.IsChecked());
}

void RadioWidgetsPage::OnUpdateUIUpdate(wxUpdateUIEvent& event)
{
    unsigned long n;
    event.Enable( m_textNumBtns->GetValue().ToULong(&n) &&
                  m_textMajorDim->GetValue().ToULong(&n) );
}

void RadioWidgetsPage::OnUpdateUISelection(wxUpdateUIEvent& event)
{
    unsigned long n;
    event.Enable( m_textSel->GetValue().ToULong(&n) &&
                   (n < (size_t)m_radio->GetCount()) );
}

void RadioWidgetsPage::OnUpdateUIReset(wxUpdateUIEvent& event)
{
    // only enable it if something is not set to default
    bool enable = m_chkVert->GetValue();

    if ( !enable )
    {
        unsigned long numEntries;

        enable = !m_textNumBtns->GetValue().ToULong(&numEntries) ||
                    numEntries != DEFAULT_NUM_ENTRIES;

        if ( !enable )
        {
            unsigned long majorDim;

            enable = !m_textMajorDim->GetValue().ToULong(&majorDim) ||
                        majorDim != DEFAULT_MAJOR_DIM;
        }
    }

    event.Enable(enable);
}

void RadioWidgetsPage::OnUpdateUIEnableItem(wxUpdateUIEvent& event)
{
    event.SetText(m_radio->IsItemEnabled(TEST_BUTTON) ? _T("Disable &2nd item")
                                                      : _T("Enable &2nd item"));
}

void RadioWidgetsPage::OnUpdateUIShowItem(wxUpdateUIEvent& event)
{
    event.SetText(m_radio->IsItemShown(TEST_BUTTON) ? _T("Hide 2nd &item")
                                                    : _T("Show 2nd &item"));
}

#endif // wxUSE_RADIOBOX
Commit	Line	Data
32b8ec41	1	/////////////////////////////////////////////////////////////////////////////
be5a51fb	2	// Program: wxWidgets Widgets Sample
32b8ec41 VZ	3	// Name: radiobox.cpp
	4	// Purpose: Part of the widgets sample showing wxRadioBox
	5	// Author: Vadim Zeitlin
	6	// Created: 15.04.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
61c083e7 WS	27	#if wxUSE_RADIOBOX
61c083e7 WS	28
32b8ec41 VZ	29	// for all others, include the necessary headers
	30	#ifndef WX_PRECOMP
	31	#include "wx/log.h"
	32
3bb70c40	33	#include "wx/bitmap.h"
32b8ec41 VZ	34	#include "wx/button.h"
	35	#include "wx/checkbox.h"
	36	#include "wx/radiobox.h"
	37	#include "wx/statbox.h"
	38	#include "wx/textctrl.h"
	39	#endif
	40
	41	#include "wx/sizer.h"
	42
	43	#include "widgets.h"
61c083e7	44
32b8ec41 VZ	45	#include "icons/radiobox.xpm"
	46
	47	// ----------------------------------------------------------------------------
	48	// constants
	49	// ----------------------------------------------------------------------------
	50
	51	// control ids
	52	enum
	53	{
f0fa4312	54	RadioPage_Reset = wxID_HIGHEST,
32b8ec41 VZ	55	RadioPage_Update,
	56	RadioPage_Selection,
	57	RadioPage_Label,
	58	RadioPage_LabelBtn,
3bfa7be9 VZ	59	RadioPage_EnableItem,
3bfa7be9 VZ	60	RadioPage_ShowItem,
32b8ec41 VZ	61	RadioPage_Radio
	62	};
	63
	64	// layout direction radiobox selections
	65	enum
	66	{
	67	RadioDir_Default,
	68	RadioDir_LtoR,
	69	RadioDir_TtoB
	70	};
	71
	72	// default values for the number of radiobox items
0c61716c VZ	73	static const unsigned int DEFAULT_NUM_ENTRIES = 12;
0c61716c VZ	74	static const unsigned int DEFAULT_MAJOR_DIM = 3;
32b8ec41	75
3bfa7be9 VZ	76	// this item is enabled/disabled shown/hidden by the test checkboxes
	77	static const int TEST_BUTTON = 1;
	78
32b8ec41 VZ	79	// ----------------------------------------------------------------------------
	80	// RadioWidgetsPage
	81	// ----------------------------------------------------------------------------
	82
	83	class RadioWidgetsPage : public WidgetsPage
	84	{
	85	public:
f2fdc4d5	86	RadioWidgetsPage(WidgetsBookCtrl book, wxImageList imaglist);
8f6eaec9	87	virtual ~RadioWidgetsPage(){};
32b8ec41	88
195df7a7	89	virtual wxControl *GetWidget() const { return m_radio; }
1301e228	90	virtual void RecreateWidget() { CreateRadio(); }
195df7a7	91
453535a7 WS	92	// lazy creation of the content
	93	virtual void CreateContent();
	94
32b8ec41 VZ	95	protected:
	96	// event handlers
	97	void OnCheckOrRadioBox(wxCommandEvent& event);
	98	void OnRadioBox(wxCommandEvent& event);
	99
	100	void OnButtonReset(wxCommandEvent& event);
	101	void OnButtonRecreate(wxCommandEvent& event);
	102
	103	void OnButtonSelection(wxCommandEvent& event);
	104	void OnButtonSetLabel(wxCommandEvent& event);
	105
3bfa7be9 VZ	106	void OnEnableItem(wxCommandEvent& event);
	107	void OnShowItem(wxCommandEvent& event);
	108
32b8ec41 VZ	109	void OnUpdateUIReset(wxUpdateUIEvent& event);
	110	void OnUpdateUIUpdate(wxUpdateUIEvent& event);
	111	void OnUpdateUISelection(wxUpdateUIEvent& event);
3bfa7be9 VZ	112	void OnUpdateUIEnableItem(wxUpdateUIEvent& event);
3bfa7be9 VZ	113	void OnUpdateUIShowItem(wxUpdateUIEvent& event);
32b8ec41 VZ	114
	115	// reset the wxRadioBox parameters
	116	void Reset();
	117
	118	// (re)create the wxRadioBox
	119	void CreateRadio();
	120
	121	// the controls
	122	// ------------
	123
	124	// the check/radio boxes for styles
	125	wxCheckBox *m_chkVert;
3bfa7be9 VZ	126	wxCheckBox *m_chkEnableItem;
3bfa7be9 VZ	127	wxCheckBox *m_chkShowItem;
32b8ec41 VZ	128	wxRadioBox *m_radioDir;
	129
	130	// the gauge itself and the sizer it is in
	131	wxRadioBox *m_radio;
	132	wxSizer *m_sizerRadio;
	133
	134	// the text entries for command parameters
	135	wxTextCtrl *m_textNumBtns,
	136	*m_textMajorDim,
	137	*m_textCurSel,
	138	*m_textSel,
	139	*m_textLabel,
	140	*m_textLabelBtns;
	141
	142	private:
5e173f35 GD	143	DECLARE_EVENT_TABLE()
5e173f35 GD	144	DECLARE_WIDGETS_PAGE(RadioWidgetsPage)
32b8ec41 VZ	145	};
	146
	147	// ----------------------------------------------------------------------------
	148	// event tables
	149	// ----------------------------------------------------------------------------
	150
	151	BEGIN_EVENT_TABLE(RadioWidgetsPage, WidgetsPage)
	152	EVT_BUTTON(RadioPage_Reset, RadioWidgetsPage::OnButtonReset)
	153
	154	EVT_BUTTON(RadioPage_Update, RadioWidgetsPage::OnButtonRecreate)
	155	EVT_BUTTON(RadioPage_LabelBtn, RadioWidgetsPage::OnButtonRecreate)
	156
	157	EVT_BUTTON(RadioPage_Selection, RadioWidgetsPage::OnButtonSelection)
	158	EVT_BUTTON(RadioPage_Label, RadioWidgetsPage::OnButtonSetLabel)
	159
	160	EVT_UPDATE_UI(RadioPage_Update, RadioWidgetsPage::OnUpdateUIUpdate)
	161	EVT_UPDATE_UI(RadioPage_Selection, RadioWidgetsPage::OnUpdateUISelection)
	162
	163	EVT_RADIOBOX(RadioPage_Radio, RadioWidgetsPage::OnRadioBox)
	164
3bfa7be9 VZ	165	EVT_CHECKBOX(RadioPage_EnableItem, RadioWidgetsPage::OnEnableItem)
	166	EVT_CHECKBOX(RadioPage_ShowItem, RadioWidgetsPage::OnShowItem)
	167
	168	EVT_UPDATE_UI(RadioPage_EnableItem, RadioWidgetsPage::OnUpdateUIEnableItem)
	169	EVT_UPDATE_UI(RadioPage_ShowItem, RadioWidgetsPage::OnUpdateUIShowItem)
	170
206d3a16 JS	171	EVT_CHECKBOX(wxID_ANY, RadioWidgetsPage::OnCheckOrRadioBox)
206d3a16 JS	172	EVT_RADIOBOX(wxID_ANY, RadioWidgetsPage::OnCheckOrRadioBox)
32b8ec41 VZ	173	END_EVENT_TABLE()
	174
	175	// ============================================================================
	176	// implementation
	177	// ============================================================================
	178
f0fa4312 WS	179	#if defined(__WXUNIVERSAL__)
	180	#define FAMILY_CTRLS UNIVERSAL_CTRLS
	181	#else
	182	#define FAMILY_CTRLS NATIVE_CTRLS
	183	#endif
	184
f2fdc4d5	185	IMPLEMENT_WIDGETS_PAGE(RadioWidgetsPage, _T("Radio"),
f0fa4312	186	FAMILY_CTRLS \| WITH_ITEMS_CTRLS
f2fdc4d5	187	);
32b8ec41	188
f2fdc4d5	189	RadioWidgetsPage::RadioWidgetsPage(WidgetsBookCtrl *book,
61c083e7	190	wxImageList *imaglist)
261357eb	191	: WidgetsPage(book, imaglist, radio_xpm)
32b8ec41	192	{
32b8ec41 VZ	193	// init everything
32b8ec41 VZ	194	m_chkVert = (wxCheckBox *)NULL;
3bfa7be9 VZ	195	m_chkEnableItem = (wxCheckBox *)NULL;
3bfa7be9 VZ	196	m_chkShowItem = (wxCheckBox *)NULL;
32b8ec41 VZ	197
	198	m_textNumBtns =
	199	m_textLabelBtns =
	200	m_textLabel = (wxTextCtrl *)NULL;
	201
	202	m_radio =
	203	m_radioDir = (wxRadioBox *)NULL;
	204	m_sizerRadio = (wxSizer *)NULL;
453535a7	205	}
32b8ec41	206
453535a7 WS	207	void RadioWidgetsPage::CreateContent()
453535a7 WS	208	{
32b8ec41 VZ	209	wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
	210
	211	// left pane
206d3a16	212	wxStaticBox *box = new wxStaticBox(this, wxID_ANY, _T("&Set style"));
32b8ec41 VZ	213
	214	wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);
	215
	216	m_chkVert = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Vertical layout"));
	217
	218	static const wxString layoutDir[] =
	219	{
	220	_T("default"),
	221	_T("left to right"),
	222	_T("top to bottom")
	223	};
	224
206d3a16	225	m_radioDir = new wxRadioBox(this, wxID_ANY, _T("Numbering:"),
32b8ec41	226	wxDefaultPosition, wxDefaultSize,
7b127900 JS	227	WXSIZEOF(layoutDir), layoutDir,
7b127900 JS	228	1, wxRA_SPECIFY_COLS);
32b8ec41 VZ	229	sizerLeft->Add(m_radioDir, 0, wxGROW \| wxALL, 5);
	230
	231	// if it's not defined, we can't change the radiobox direction
	232	#ifndef wxRA_LEFTTORIGHT
	233	m_radioDir->Disable();
	234	#endif // wxRA_LEFTTORIGHT
	235
	236	wxSizer *sizerRow;
7b127900	237	sizerRow = CreateSizerWithTextAndLabel(_T("&Major dimension:"),
206d3a16	238	wxID_ANY,
32b8ec41 VZ	239	&m_textMajorDim);
	240	sizerLeft->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	241
7b127900	242	sizerRow = CreateSizerWithTextAndLabel(_T("&Number of buttons:"),
206d3a16	243	wxID_ANY,
32b8ec41 VZ	244	&m_textNumBtns);
	245	sizerLeft->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	246
	247	wxButton *btn;
	248	btn = new wxButton(this, RadioPage_Update, _T("&Update"));
	249	sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL \| wxALL, 5);
	250
	251	sizerLeft->Add(5, 5, 0, wxGROW \| wxALL, 5); // spacer
	252
	253	btn = new wxButton(this, RadioPage_Reset, _T("&Reset"));
	254	sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL \| wxALL, 15);
	255
	256	// middle pane
206d3a16	257	wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, _T("&Change parameters"));
32b8ec41 VZ	258	wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
32b8ec41 VZ	259
7b127900	260	sizerRow = CreateSizerWithTextAndLabel(_T("Current selection:"),
206d3a16	261	wxID_ANY,
32b8ec41 VZ	262	&m_textCurSel);
	263	sizerMiddle->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	264
	265	sizerRow = CreateSizerWithTextAndButton(RadioPage_Selection,
7b127900	266	_T("&Change selection:"),
206d3a16	267	wxID_ANY,
32b8ec41 VZ	268	&m_textSel);
	269	sizerMiddle->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	270
	271	sizerRow = CreateSizerWithTextAndButton(RadioPage_Label,
7b127900	272	_T("&Label for box:"),
206d3a16	273	wxID_ANY,
32b8ec41 VZ	274	&m_textLabel);
	275	sizerMiddle->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	276
	277	sizerRow = CreateSizerWithTextAndButton(RadioPage_LabelBtn,
7b127900	278	_T("&Label for buttons:"),
206d3a16	279	wxID_ANY,
32b8ec41 VZ	280	&m_textLabelBtns);
	281	sizerMiddle->Add(sizerRow, 0, wxGROW \| wxALL, 5);
	282
3bfa7be9 VZ	283	m_chkEnableItem = CreateCheckBoxAndAddToSizer(sizerMiddle,
	284	_T("Disable &2nd item"),
	285	RadioPage_EnableItem);
	286	m_chkShowItem = CreateCheckBoxAndAddToSizer(sizerMiddle,
	287	_T("Hide 2nd &item"),
	288	RadioPage_ShowItem);
8b6d589d	289
32b8ec41 VZ	290	// right pane
32b8ec41 VZ	291	wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
7b127900	292	sizerRight->SetMinSize(150, 0);
32b8ec41 VZ	293	m_sizerRadio = sizerRight; // save it to modify it later
	294
	295	Reset();
	296	CreateRadio();
	297
	298	// the 3 panes panes compose the window
	299	sizerTop->Add(sizerLeft, 0, wxGROW \| (wxALL & ~wxLEFT), 10);
	300	sizerTop->Add(sizerMiddle, 1, wxGROW \| wxALL, 10);
7b127900	301	sizerTop->Add(sizerRight, 0, wxGROW \| (wxALL & ~wxRIGHT), 10);
32b8ec41 VZ	302
32b8ec41 VZ	303	// final initializations
32b8ec41	304	SetSizer(sizerTop);
32b8ec41 VZ	305	}
32b8ec41 VZ	306
32b8ec41 VZ	307	// ----------------------------------------------------------------------------
	308	// operations
	309	// ----------------------------------------------------------------------------
	310
	311	void RadioWidgetsPage::Reset()
	312	{
0c61716c VZ	313	m_textMajorDim->SetValue(wxString::Format(_T("%u"), DEFAULT_MAJOR_DIM));
0c61716c VZ	314	m_textNumBtns->SetValue(wxString::Format(_T("%u"), DEFAULT_NUM_ENTRIES));
32b8ec41 VZ	315	m_textLabel->SetValue(_T("I'm a radiobox"));
	316	m_textLabelBtns->SetValue(_T("item"));
	317
206d3a16	318	m_chkVert->SetValue(false);
3bfa7be9 VZ	319	m_chkEnableItem->SetValue(true);
3bfa7be9 VZ	320	m_chkShowItem->SetValue(true);
32b8ec41 VZ	321	m_radioDir->SetSelection(RadioDir_Default);
	322	}
	323
	324	void RadioWidgetsPage::CreateRadio()
	325	{
	326	int sel;
	327	if ( m_radio )
	328	{
	329	sel = m_radio->GetSelection();
	330
12a3f227	331	m_sizerRadio->Detach( m_radio );
32b8ec41 VZ	332
	333	delete m_radio;
	334	}
	335	else // first time creation, no old selection to preserve
	336	{
	337	sel = -1;
	338	}
	339
	340	unsigned long count;
	341	if ( !m_textNumBtns->GetValue().ToULong(&count) )
	342	{
	343	wxLogWarning(_T("Should have a valid number for number of items."));
	344
	345	// fall back to default
	346	count = DEFAULT_NUM_ENTRIES;
	347	}
	348
	349	unsigned long majorDim;
	350	if ( !m_textMajorDim->GetValue().ToULong(&majorDim) )
	351	{
	352	wxLogWarning(_T("Should have a valid major dimension number."));
	353
	354	// fall back to default
	355	majorDim = DEFAULT_MAJOR_DIM;
	356	}
	357
	358	wxString *items = new wxString[count];
	359
	360	wxString labelBtn = m_textLabelBtns->GetValue();
	361	for ( size_t n = 0; n < count; n++ )
	362	{
0c61716c VZ	363	items[n] = wxString::Format(_T("%s %lu"),
0c61716c VZ	364	labelBtn.c_str(), (unsigned long)n + 1);
32b8ec41 VZ	365	}
	366
	367	int flags = m_chkVert->GetValue() ? wxRA_VERTICAL
	368	: wxRA_HORIZONTAL;
	369
1301e228 VZ	370	flags \|= ms_defaultFlags;
1301e228 VZ	371
32b8ec41 VZ	372	#ifdef wxRA_LEFTTORIGHT
	373	switch ( m_radioDir->GetSelection() )
	374	{
	375	default:
	376	wxFAIL_MSG( _T("unexpected wxRadioBox layout direction") );
	377	// fall through
	378
	379	case RadioDir_Default:
	380	break;
	381
	382	case RadioDir_LtoR:
	383	flags \|= wxRA_LEFTTORIGHT;
	384	break;
	385
	386	case RadioDir_TtoB:
	387	flags \|= wxRA_TOPTOBOTTOM;
	388	break;
	389	}
	390	#endif // wxRA_LEFTTORIGHT
	391
	392	m_radio = new wxRadioBox(this, RadioPage_Radio,
	393	m_textLabel->GetValue(),
	394	wxDefaultPosition, wxDefaultSize,
	395	count, items,
	396	majorDim,
	397	flags);
	398
	399	delete [] items;
	400
	401	if ( sel >= 0 && (size_t)sel < count )
	402	{
	403	m_radio->SetSelection(sel);
	404	}
	405
	406	m_sizerRadio->Add(m_radio, 1, wxGROW);
	407	m_sizerRadio->Layout();
8b6d589d	408
3bfa7be9 VZ	409	m_chkEnableItem->SetValue(true);
3bfa7be9 VZ	410	m_chkEnableItem->SetValue(true);
32b8ec41 VZ	411	}
	412
	413	// ----------------------------------------------------------------------------
	414	// event handlers
	415	// ----------------------------------------------------------------------------
	416
	417	void RadioWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
	418	{
	419	Reset();
	420
	421	CreateRadio();
	422	}
	423
c02e5a31	424	void RadioWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
32b8ec41 VZ	425	{
	426	CreateRadio();
	427	}
	428
	429	void RadioWidgetsPage::OnRadioBox(wxCommandEvent& event)
	430	{
	431	int sel = m_radio->GetSelection();
dacaa6f1 JS	432	int event_sel = event.GetSelection();
dacaa6f1 JS	433	wxUnusedVar(event_sel);
32b8ec41 VZ	434
	435	wxLogMessage(_T("Radiobox selection changed, now %d"), sel);
	436
dacaa6f1	437	wxASSERT_MSG( sel == event_sel,
32b8ec41 VZ	438	_T("selection should be the same in event and radiobox") );
	439
	440	m_textCurSel->SetValue(wxString::Format(_T("%d"), sel));
	441	}
	442
	443	void RadioWidgetsPage::OnButtonRecreate(wxCommandEvent& WXUNUSED(event))
	444	{
	445	CreateRadio();
	446	}
	447
	448	void RadioWidgetsPage::OnButtonSetLabel(wxCommandEvent& WXUNUSED(event))
	449	{
	450	m_radio->wxControl::SetLabel(m_textLabel->GetValue());
	451	}
	452
	453	void RadioWidgetsPage::OnButtonSelection(wxCommandEvent& WXUNUSED(event))
	454	{
	455	unsigned long sel;
	456	if ( !m_textSel->GetValue().ToULong(&sel) \|\|
	457	(sel >= (size_t)m_radio->GetCount()) )
	458	{
	459	wxLogWarning(_T("Invalid number specified as new selection."));
	460	}
	461	else
	462	{
	463	m_radio->SetSelection(sel);
	464	}
	465	}
	466
3bfa7be9 VZ	467	void RadioWidgetsPage::OnEnableItem(wxCommandEvent& event)
	468	{
	469	m_radio->Enable(TEST_BUTTON, event.IsChecked());
	470	}
	471
	472	void RadioWidgetsPage::OnShowItem(wxCommandEvent& event)
	473	{
	474	m_radio->Show(TEST_BUTTON, event.IsChecked());
	475	}
	476
32b8ec41 VZ	477	void RadioWidgetsPage::OnUpdateUIUpdate(wxUpdateUIEvent& event)
	478	{
	479	unsigned long n;
	480	event.Enable( m_textNumBtns->GetValue().ToULong(&n) &&
	481	m_textMajorDim->GetValue().ToULong(&n) );
	482	}
	483
	484	void RadioWidgetsPage::OnUpdateUISelection(wxUpdateUIEvent& event)
	485	{
	486	unsigned long n;
	487	event.Enable( m_textSel->GetValue().ToULong(&n) &&
	488	(n < (size_t)m_radio->GetCount()) );
	489	}
	490
	491	void RadioWidgetsPage::OnUpdateUIReset(wxUpdateUIEvent& event)
	492	{
	493	// only enable it if something is not set to default
	494	bool enable = m_chkVert->GetValue();
	495
	496	if ( !enable )
	497	{
	498	unsigned long numEntries;
	499
	500	enable = !m_textNumBtns->GetValue().ToULong(&numEntries) \|\|
	501	numEntries != DEFAULT_NUM_ENTRIES;
	502
	503	if ( !enable )
	504	{
	505	unsigned long majorDim;
	506
	507	enable = !m_textMajorDim->GetValue().ToULong(&majorDim) \|\|
	508	majorDim != DEFAULT_MAJOR_DIM;
	509	}
	510	}
	511
	512	event.Enable(enable);
	513	}
	514
3bfa7be9 VZ	515	void RadioWidgetsPage::OnUpdateUIEnableItem(wxUpdateUIEvent& event)
	516	{
	517	event.SetText(m_radio->IsItemEnabled(TEST_BUTTON) ? _T("Disable &2nd item")
	518	: _T("Enable &2nd item"));
	519	}
	520
	521	void RadioWidgetsPage::OnUpdateUIShowItem(wxUpdateUIEvent& event)
	522	{
	523	event.SetText(m_radio->IsItemShown(TEST_BUTTON) ? _T("Hide 2nd &item")
	524	: _T("Show 2nd &item"));
	525	}
	526
61c083e7	527	#endif // wxUSE_RADIOBOX