src/common/dlgcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        common/dlgcmn.cpp
// Purpose:     common (to all ports) wxDialog functions
// Author:      Vadim Zeitlin
// Modified by:
// Created:     28.06.99
// RCS-ID:      $Id$
// Copyright:   (c) Vadim Zeitlin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/button.h"
    #include "wx/dialog.h"
    #include "wx/dcclient.h"
    #include "wx/intl.h"
    #include "wx/settings.h"
    #include "wx/stattext.h"
    #include "wx/sizer.h"
    #include "wx/button.h"
    #include "wx/containr.h"
#endif

#include "wx/statline.h"
#include "wx/sysopt.h"

#if wxUSE_STATTEXT

// ----------------------------------------------------------------------------
// wxTextWrapper
// ----------------------------------------------------------------------------

// this class is used to wrap the text on word boundary: wrapping is done by
// calling OnStartLine() and OnOutputLine() functions
class wxTextWrapper
{
public:
    wxTextWrapper() { m_eol = false; }

    // win is used for getting the font, text is the text to wrap, width is the
    // max line width or -1 to disable wrapping
    void Wrap(wxWindow *win, const wxString& text, int widthMax);

    // we don't need it, but just to avoid compiler warnings
    virtual ~wxTextWrapper() { }

protected:
    // line may be empty
    virtual void OnOutputLine(const wxString& line) = 0;

    // called at the start of every new line (except the very first one)
    virtual void OnNewLine() { }

private:
    // call OnOutputLine() and set m_eol to true
    void DoOutputLine(const wxString& line)
    {
        OnOutputLine(line);

        m_eol = true;
    }

    // this function is a destructive inspector: when it returns true it also
    // resets the flag to false so calling it again woulnd't return true any
    // more
    bool IsStartOfNewLine()
    {
        if ( !m_eol )
            return false;

        m_eol = false;

        return true;
    }


    bool m_eol;
};

#endif // wxUSE_STATTEXT

// ----------------------------------------------------------------------------
// wxDialogBase
// ----------------------------------------------------------------------------

// FIXME - temporary hack in absence of wxTopLevelWindow, should be always used
#ifdef wxTopLevelWindowNative
BEGIN_EVENT_TABLE(wxDialogBase, wxTopLevelWindow)
    WX_EVENT_TABLE_CONTROL_CONTAINER(wxDialogBase)
END_EVENT_TABLE()

WX_DELEGATE_TO_CONTROL_CONTAINER(wxDialogBase)
#endif

void wxDialogBase::Init()
{
    m_returnCode = 0;
    m_affirmativeId = wxID_OK;
    m_escapeId = wxID_ANY;

    // the dialogs have this flag on by default to prevent the events from the
    // dialog controls from reaching the parent frame which is usually
    // undesirable and can lead to unexpected and hard to find bugs
    SetExtraStyle(GetExtraStyle() | wxWS_EX_BLOCK_EVENTS);

#ifdef wxTopLevelWindowNative // FIXME - temporary hack, should be always used!
    m_container.SetContainerWindow(this);
#endif
}

#if wxUSE_STATTEXT

void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
{
    const wxChar *lastSpace = NULL;
    wxString line;

    const wxChar *lineStart = text.c_str();
    for ( const wxChar *p = lineStart; ; p++ )
    {
        if ( IsStartOfNewLine() )
        {
            OnNewLine();

            lastSpace = NULL;
            line.clear();
            lineStart = p;
        }

        if ( *p == _T('\n') || *p == _T('\0') )
        {
            DoOutputLine(line);

            if ( *p == _T('\0') )
                break;
        }
        else // not EOL
        {
            if ( *p == _T(' ') )
                lastSpace = p;

            line += *p;

            if ( widthMax >= 0 && lastSpace )
            {
                int width;
                win->GetTextExtent(line, &width, NULL);

                if ( width > widthMax )
                {
                    // remove the last word from this line
                    line.erase(lastSpace - lineStart, p + 1 - lineStart);
                    DoOutputLine(line);

                    // go back to the last word of this line which we didn't
                    // output yet
                    p = lastSpace;
                }
            }
            //else: no wrapping at all or impossible to wrap
        }
    }
}

class wxTextSizerWrapper : public wxTextWrapper
{
public:
    wxTextSizerWrapper(wxWindow *win)
    {
        m_win = win;
        m_hLine = 0;
    }

    wxSizer *CreateSizer(const wxString& text, int widthMax)
    {
        m_sizer = new wxBoxSizer(wxVERTICAL);
        Wrap(m_win, text, widthMax);
        return m_sizer;
    }

protected:
    virtual void OnOutputLine(const wxString& line)
    {
        if ( !line.empty() )
        {
            m_sizer->Add(new wxStaticText(m_win, wxID_ANY, line));
        }
        else // empty line, no need to create a control for it
        {
            if ( !m_hLine )
                m_hLine = m_win->GetCharHeight();

            m_sizer->Add(5, m_hLine);
        }
    }

private:
    wxWindow *m_win;
    wxSizer *m_sizer;
    int m_hLine;
};

wxSizer *wxDialogBase::CreateTextSizer(const wxString& message)
{
    // I admit that this is complete bogus, but it makes
    // message boxes work for pda screens temporarily..
    int widthMax = -1;
    const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA;
    if (is_pda)
    {
        widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25;
    }

    // '&' is used as accel mnemonic prefix in the wxWidgets controls but in
    // the static messages created by CreateTextSizer() (used by wxMessageBox,
    // for example), we don't want this special meaning, so we need to quote it
    wxString text(message);
    text.Replace(_T("&"), _T("&&"));

    wxTextSizerWrapper wrapper(this);

    return wrapper.CreateSizer(text, widthMax);
}

class wxLabelWrapper : public wxTextWrapper
{
public:
    void WrapLabel(wxWindow *text, int widthMax)
    {
        m_text.clear();
        Wrap(text, text->GetLabel(), widthMax);
        text->SetLabel(m_text);
    }

protected:
    virtual void OnOutputLine(const wxString& line)
    {
        m_text += line;
    }

    virtual void OnNewLine()
    {
        m_text += _T('\n');
    }

private:
    wxString m_text;
};

// NB: don't "factor out" the scope operator, SGI MIPSpro 7.3 (but not 7.4)
//     gets confused if it doesn't immediately follow the class name
void
#if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
wxStaticText::
#else
wxStaticTextBase::
#endif
Wrap(int width)
{
    wxLabelWrapper wrapper;
    wrapper.WrapLabel(this, width);
}

#endif // wxUSE_STATTEXT

wxSizer *wxDialogBase::CreateButtonSizer( long flags, bool separated, wxCoord distance )
{
#ifdef __SMARTPHONE__
    wxUnusedVar(separated);
    wxUnusedVar(distance);

    wxDialog* dialog = (wxDialog*) this;
    if (flags & wxOK){
        dialog->SetLeftMenu(wxID_OK);
    }

    if (flags & wxCANCEL){
        dialog->SetRightMenu(wxID_CANCEL);
    }

    if (flags & wxYES){
        dialog->SetLeftMenu(wxID_YES);
    }

    if (flags & wxNO){
        dialog->SetLeftMenu(wxID_NO);
    }
    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
    return sizer;

#else // !__SMARTPHONE__

#ifdef __POCKETPC__
    // PocketPC guidelines recommend for Ok/Cancel dialogs to use
    // OK button located inside caption bar and implement Cancel functionality
    // through Undo outside dialog. As native behaviour this will be default
    // here but can be easily replaced with real wxButtons
    // with "wince.dialog.real-ok-cancel" option set to 1
    if ( ((flags & ~(wxCANCEL|wxNO_DEFAULT))== wxOK) &&
         (wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel"))==0)
       )
    {
        wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
        return sizer;
    }
#endif // __POCKETPC__

#if wxUSE_BUTTON

    wxSizer* buttonSizer = CreateStdDialogButtonSizer( flags );

    // Mac Human Interface Guidelines recommend not to use static lines as grouping elements
#if wxUSE_STATLINE && !defined(__WXMAC__)
    if(!separated)
        return buttonSizer;

    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
    topsizer->Add( new wxStaticLine( this, wxID_ANY ), 0, wxEXPAND | wxBOTTOM, distance );
    topsizer->Add( buttonSizer, 0, wxEXPAND );
    return topsizer;

#else // !wxUSE_STATLINE

    wxUnusedVar(separated);
    wxUnusedVar(distance);
    return buttonSizer;

#endif // wxUSE_STATLINE/!wxUSE_STATLINE

#else // !wxUSE_BUTTON

    wxUnusedVar(separated);
    wxUnusedVar(distance);
    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
    return sizer;

#endif // wxUSE_BUTTON/!wxUSE_BUTTON

#endif // __SMARTPHONE__/!__SMARTPHONE__
}

#if wxUSE_BUTTON

wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags )
{
    wxStdDialogButtonSizer *sizer = new wxStdDialogButtonSizer();

    wxButton *ok = NULL;
    wxButton *yes = NULL;
    wxButton *no = NULL;

    if (flags & wxOK){
        ok = new wxButton(this, wxID_OK);
        sizer->AddButton(ok);
    }

    if (flags & wxCANCEL){
        wxButton *cancel = new wxButton(this, wxID_CANCEL);
        sizer->AddButton(cancel);
    }

    if (flags & wxYES){
        yes = new wxButton(this, wxID_YES);
        sizer->AddButton(yes);
    }

    if (flags & wxNO){
        no = new wxButton(this, wxID_NO);
        sizer->AddButton(no);
    }

    if (flags & wxHELP){
        wxButton *help = new wxButton(this, wxID_HELP);
        sizer->AddButton(help);
    }

    if (flags & wxNO_DEFAULT)
    {
        if (no)
        {
            no->SetDefault();
            no->SetFocus();
        }
    }
    else
    {
        if (ok)
        {
            ok->SetDefault();
            ok->SetFocus();
        }
        else if (yes)
        {
            yes->SetDefault();
            yes->SetFocus();
        }
    }

    if (flags & wxOK)
        SetAffirmativeId(wxID_OK);
    else if (flags & wxYES)
        SetAffirmativeId(wxID_YES);

    sizer->Realize();

    return sizer;
}

#endif // wxUSE_BUTTON
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: common/dlgcmn.cpp
	3	// Purpose: common (to all ports) wxDialog functions
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 28.06.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Vadim Zeitlin
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#ifndef WX_PRECOMP
	28	#include "wx/button.h"
	29	#include "wx/dialog.h"
	30	#include "wx/dcclient.h"
	31	#include "wx/intl.h"
	32	#include "wx/settings.h"
	33	#include "wx/stattext.h"
	34	#include "wx/sizer.h"
	35	#include "wx/button.h"
	36	#include "wx/containr.h"
	37	#endif
	38
	39	#include "wx/statline.h"
	40	#include "wx/sysopt.h"
	41
	42	#if wxUSE_STATTEXT
	43
	44	// ----------------------------------------------------------------------------
	45	// wxTextWrapper
	46	// ----------------------------------------------------------------------------
	47
	48	// this class is used to wrap the text on word boundary: wrapping is done by
	49	// calling OnStartLine() and OnOutputLine() functions
	50	class wxTextWrapper
	51	{
	52	public:
	53	wxTextWrapper() { m_eol = false; }
	54
	55	// win is used for getting the font, text is the text to wrap, width is the
	56	// max line width or -1 to disable wrapping
	57	void Wrap(wxWindow *win, const wxString& text, int widthMax);
	58
	59	// we don't need it, but just to avoid compiler warnings
	60	virtual ~wxTextWrapper() { }
	61
	62	protected:
	63	// line may be empty
	64	virtual void OnOutputLine(const wxString& line) = 0;
	65
	66	// called at the start of every new line (except the very first one)
	67	virtual void OnNewLine() { }
	68
	69	private:
	70	// call OnOutputLine() and set m_eol to true
	71	void DoOutputLine(const wxString& line)
	72	{
	73	OnOutputLine(line);
	74
	75	m_eol = true;
	76	}
	77
	78	// this function is a destructive inspector: when it returns true it also
	79	// resets the flag to false so calling it again woulnd't return true any
	80	// more
	81	bool IsStartOfNewLine()
	82	{
	83	if ( !m_eol )
	84	return false;
	85
	86	m_eol = false;
	87
	88	return true;
	89	}
	90
	91
	92	bool m_eol;
	93	};
	94
	95	#endif // wxUSE_STATTEXT
	96
	97	// ----------------------------------------------------------------------------
	98	// wxDialogBase
	99	// ----------------------------------------------------------------------------
	100
	101	// FIXME - temporary hack in absence of wxTopLevelWindow, should be always used
	102	#ifdef wxTopLevelWindowNative
	103	BEGIN_EVENT_TABLE(wxDialogBase, wxTopLevelWindow)
	104	WX_EVENT_TABLE_CONTROL_CONTAINER(wxDialogBase)
	105	END_EVENT_TABLE()
	106
	107	WX_DELEGATE_TO_CONTROL_CONTAINER(wxDialogBase)
	108	#endif
	109
	110	void wxDialogBase::Init()
	111	{
	112	m_returnCode = 0;
	113	m_affirmativeId = wxID_OK;
	114	m_escapeId = wxID_ANY;
	115
	116	// the dialogs have this flag on by default to prevent the events from the
	117	// dialog controls from reaching the parent frame which is usually
	118	// undesirable and can lead to unexpected and hard to find bugs
	119	SetExtraStyle(GetExtraStyle() \| wxWS_EX_BLOCK_EVENTS);
	120
	121	#ifdef wxTopLevelWindowNative // FIXME - temporary hack, should be always used!
	122	m_container.SetContainerWindow(this);
	123	#endif
	124	}
	125
	126	#if wxUSE_STATTEXT
	127
	128	void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
	129	{
	130	const wxChar *lastSpace = NULL;
	131	wxString line;
	132
	133	const wxChar *lineStart = text.c_str();
	134	for ( const wxChar *p = lineStart; ; p++ )
	135	{
	136	if ( IsStartOfNewLine() )
	137	{
	138	OnNewLine();
	139
	140	lastSpace = NULL;
	141	line.clear();
	142	lineStart = p;
	143	}
	144
	145	if ( p == _T('\n') \|\| p == _T('\0') )
	146	{
	147	DoOutputLine(line);
	148
	149	if ( *p == _T('\0') )
	150	break;
	151	}
	152	else // not EOL
	153	{
	154	if ( *p == _T(' ') )
	155	lastSpace = p;
	156
	157	line += *p;
	158
	159	if ( widthMax >= 0 && lastSpace )
	160	{
	161	int width;
	162	win->GetTextExtent(line, &width, NULL);
	163
	164	if ( width > widthMax )
	165	{
	166	// remove the last word from this line
	167	line.erase(lastSpace - lineStart, p + 1 - lineStart);
	168	DoOutputLine(line);
	169
	170	// go back to the last word of this line which we didn't
	171	// output yet
	172	p = lastSpace;
	173	}
	174	}
	175	//else: no wrapping at all or impossible to wrap
	176	}
	177	}
	178	}
	179
	180	class wxTextSizerWrapper : public wxTextWrapper
	181	{
	182	public:
	183	wxTextSizerWrapper(wxWindow *win)
	184	{
	185	m_win = win;
	186	m_hLine = 0;
	187	}
	188
	189	wxSizer *CreateSizer(const wxString& text, int widthMax)
	190	{
	191	m_sizer = new wxBoxSizer(wxVERTICAL);
	192	Wrap(m_win, text, widthMax);
	193	return m_sizer;
	194	}
	195
	196	protected:
	197	virtual void OnOutputLine(const wxString& line)
	198	{
	199	if ( !line.empty() )
	200	{
	201	m_sizer->Add(new wxStaticText(m_win, wxID_ANY, line));
	202	}
	203	else // empty line, no need to create a control for it
	204	{
	205	if ( !m_hLine )
	206	m_hLine = m_win->GetCharHeight();
	207
	208	m_sizer->Add(5, m_hLine);
	209	}
	210	}
	211
	212	private:
	213	wxWindow *m_win;
	214	wxSizer *m_sizer;
	215	int m_hLine;
	216	};
	217
	218	wxSizer *wxDialogBase::CreateTextSizer(const wxString& message)
	219	{
	220	// I admit that this is complete bogus, but it makes
	221	// message boxes work for pda screens temporarily..
	222	int widthMax = -1;
	223	const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA;
	224	if (is_pda)
	225	{
	226	widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25;
	227	}
	228
	229	// '&' is used as accel mnemonic prefix in the wxWidgets controls but in
	230	// the static messages created by CreateTextSizer() (used by wxMessageBox,
	231	// for example), we don't want this special meaning, so we need to quote it
	232	wxString text(message);
	233	text.Replace(_T("&"), _T("&&"));
	234
	235	wxTextSizerWrapper wrapper(this);
	236
	237	return wrapper.CreateSizer(text, widthMax);
	238	}
	239
	240	class wxLabelWrapper : public wxTextWrapper
	241	{
	242	public:
	243	void WrapLabel(wxWindow *text, int widthMax)
	244	{
	245	m_text.clear();
	246	Wrap(text, text->GetLabel(), widthMax);
	247	text->SetLabel(m_text);
	248	}
	249
	250	protected:
	251	virtual void OnOutputLine(const wxString& line)
	252	{
	253	m_text += line;
	254	}
	255
	256	virtual void OnNewLine()
	257	{
	258	m_text += _T('\n');
	259	}
	260
	261	private:
	262	wxString m_text;
	263	};
	264
	265	// NB: don't "factor out" the scope operator, SGI MIPSpro 7.3 (but not 7.4)
	266	// gets confused if it doesn't immediately follow the class name
	267	void
	268	#if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
	269	wxStaticText::
	270	#else
	271	wxStaticTextBase::
	272	#endif
	273	Wrap(int width)
	274	{
	275	wxLabelWrapper wrapper;
	276	wrapper.WrapLabel(this, width);
	277	}
	278
	279	#endif // wxUSE_STATTEXT
	280
	281	wxSizer *wxDialogBase::CreateButtonSizer( long flags, bool separated, wxCoord distance )
	282	{
	283	#ifdef __SMARTPHONE__
	284	wxUnusedVar(separated);
	285	wxUnusedVar(distance);
	286
	287	wxDialog* dialog = (wxDialog*) this;
	288	if (flags & wxOK){
	289	dialog->SetLeftMenu(wxID_OK);
	290	}
	291
	292	if (flags & wxCANCEL){
	293	dialog->SetRightMenu(wxID_CANCEL);
	294	}
	295
	296	if (flags & wxYES){
	297	dialog->SetLeftMenu(wxID_YES);
	298	}
	299
	300	if (flags & wxNO){
	301	dialog->SetLeftMenu(wxID_NO);
	302	}
	303	wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
	304	return sizer;
	305
	306	#else // !__SMARTPHONE__
	307
	308	#ifdef __POCKETPC__
	309	// PocketPC guidelines recommend for Ok/Cancel dialogs to use
	310	// OK button located inside caption bar and implement Cancel functionality
	311	// through Undo outside dialog. As native behaviour this will be default
	312	// here but can be easily replaced with real wxButtons
	313	// with "wince.dialog.real-ok-cancel" option set to 1
	314	if ( ((flags & ~(wxCANCEL\|wxNO_DEFAULT))== wxOK) &&
	315	(wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel"))==0)
	316	)
	317	{
	318	wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
	319	return sizer;
	320	}
	321	#endif // __POCKETPC__
	322
	323	#if wxUSE_BUTTON
	324
	325	wxSizer* buttonSizer = CreateStdDialogButtonSizer( flags );
	326
	327	// Mac Human Interface Guidelines recommend not to use static lines as grouping elements
	328	#if wxUSE_STATLINE && !defined(__WXMAC__)
	329	if(!separated)
	330	return buttonSizer;
	331
	332	wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
	333	topsizer->Add( new wxStaticLine( this, wxID_ANY ), 0, wxEXPAND \| wxBOTTOM, distance );
	334	topsizer->Add( buttonSizer, 0, wxEXPAND );
	335	return topsizer;
	336
	337	#else // !wxUSE_STATLINE
	338
	339	wxUnusedVar(separated);
	340	wxUnusedVar(distance);
	341	return buttonSizer;
	342
	343	#endif // wxUSE_STATLINE/!wxUSE_STATLINE
	344
	345	#else // !wxUSE_BUTTON
	346
	347	wxUnusedVar(separated);
	348	wxUnusedVar(distance);
	349	wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
	350	return sizer;
	351
	352	#endif // wxUSE_BUTTON/!wxUSE_BUTTON
	353
	354	#endif // __SMARTPHONE__/!__SMARTPHONE__
	355	}
	356
	357	#if wxUSE_BUTTON
	358
	359	wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags )
	360	{
	361	wxStdDialogButtonSizer *sizer = new wxStdDialogButtonSizer();
	362
	363	wxButton *ok = NULL;
	364	wxButton *yes = NULL;
	365	wxButton *no = NULL;
	366
	367	if (flags & wxOK){
	368	ok = new wxButton(this, wxID_OK);
	369	sizer->AddButton(ok);
	370	}
	371
	372	if (flags & wxCANCEL){
	373	wxButton *cancel = new wxButton(this, wxID_CANCEL);
	374	sizer->AddButton(cancel);
	375	}
	376
	377	if (flags & wxYES){
	378	yes = new wxButton(this, wxID_YES);
	379	sizer->AddButton(yes);
	380	}
	381
	382	if (flags & wxNO){
	383	no = new wxButton(this, wxID_NO);
	384	sizer->AddButton(no);
	385	}
	386
	387	if (flags & wxHELP){
	388	wxButton *help = new wxButton(this, wxID_HELP);
	389	sizer->AddButton(help);
	390	}
	391
	392	if (flags & wxNO_DEFAULT)
	393	{
	394	if (no)
	395	{
	396	no->SetDefault();
	397	no->SetFocus();
	398	}
	399	}
	400	else
	401	{
	402	if (ok)
	403	{
	404	ok->SetDefault();
	405	ok->SetFocus();
	406	}
	407	else if (yes)
	408	{
	409	yes->SetDefault();
	410	yes->SetFocus();
	411	}
	412	}
	413
	414	if (flags & wxOK)
	415	SetAffirmativeId(wxID_OK);
	416	else if (flags & wxYES)
	417	SetAffirmativeId(wxID_YES);
	418
	419	sizer->Realize();
	420
	421	return sizer;
	422	}
	423
	424	#endif // wxUSE_BUTTON