[wxWidgets.git] / samples / popup / popup.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        minimal.cpp
// Purpose:     Popup wxWidgets sample
// Author:      Robert Roebling
// Modified by:
// Created:     2005-02-04
// RCS-ID:      $Id$
// Copyright:   (c) 2005 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// 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 (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/popupwin.h"
#include "wx/spinctrl.h"

// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------

// the application icon (under Windows and OS/2 it is in resources and even
// though we could still include the XPM here it would be unused)
#if !defined(__WXMSW__) && !defined(__WXPM__)
    #include "../sample.xpm"
#endif

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

// IDs for the controls and the menu commands
enum
{
    Minimal_Quit = wxID_EXIT,
    Minimal_About = wxID_ABOUT,
    Minimal_TestDialog,
    Minimal_StartSimplePopup,
    Minimal_StartScrolledPopup,
    Minimal_LogWindow,
    Minimal_PopupButton,
    Minimal_PopupSpinctrl
};

//----------------------------------------------------------------------------
// SimpleTransientPopup
//----------------------------------------------------------------------------
class SimpleTransientPopup: public wxPopupTransientWindow
{
public:
    SimpleTransientPopup( wxWindow *parent );
    virtual ~SimpleTransientPopup();

    // wxPopupTransientWindow virtual methods are all overridden to log them
    virtual void Popup(wxWindow *focus = NULL);
    virtual void OnDismiss();
    virtual bool ProcessLeftDown(wxMouseEvent& event);
    virtual bool Show( bool show = true );

    wxScrolledWindow* GetChild() { return m_panel; }

private:
    wxScrolledWindow *m_panel;
    wxButton *m_button;
    wxSpinCtrl *m_spinCtrl;

private:
    void OnMouse( wxMouseEvent &event );
    void OnSize( wxSizeEvent &event );
    void OnSetFocus( wxFocusEvent &event );
    void OnKillFocus( wxFocusEvent &event );
    void OnButton( wxCommandEvent& event );
    void OnSpinCtrl( wxSpinEvent& event );

private:
    DECLARE_CLASS(SimpleTransientPopup)
    DECLARE_EVENT_TABLE()
};

//----------------------------------------------------------------------------
// SimpleTransientPopup
//----------------------------------------------------------------------------
IMPLEMENT_CLASS(SimpleTransientPopup,wxPopupTransientWindow)

BEGIN_EVENT_TABLE(SimpleTransientPopup,wxPopupTransientWindow)
    EVT_MOUSE_EVENTS( SimpleTransientPopup::OnMouse )
    EVT_SIZE( SimpleTransientPopup::OnSize )
    EVT_SET_FOCUS( SimpleTransientPopup::OnSetFocus )
    EVT_KILL_FOCUS( SimpleTransientPopup::OnKillFocus )
    EVT_BUTTON( Minimal_PopupButton, SimpleTransientPopup::OnButton )
    EVT_SPINCTRL( Minimal_PopupSpinctrl, SimpleTransientPopup::OnSpinCtrl )
END_EVENT_TABLE()

SimpleTransientPopup::SimpleTransientPopup( wxWindow *parent ) :
    wxPopupTransientWindow( parent )
{
    m_panel = new wxScrolledWindow( this, wxID_ANY );
    m_panel->SetBackgroundColour( *wxLIGHT_GREY );
    wxStaticText *text = new wxStaticText( m_panel, wxID_ANY,
                          wxT("wx.PopupTransientWindow is a\n")
                          wxT("wx.PopupWindow which disappears\n")
                          wxT("automatically when the user\n")
                          wxT("clicks the mouse outside it or if it\n")
                          wxT("(or its first child) loses focus in \n")
                          wxT("any other way."), wxPoint( 10,10) );
    wxSize size = text->GetBestSize();

    m_button = new wxButton(m_panel, Minimal_PopupButton, wxT("Press Me"), wxPoint(0, size.y + 10));
    size.y = m_button->GetRect().GetBottom();
    m_spinCtrl = new wxSpinCtrl(m_panel, Minimal_PopupSpinctrl, wxT("Hello"), wxPoint(0, size.y + 5));
    size.y = m_spinCtrl->GetRect().GetBottom();

    m_panel->SetSize( size.x+20, size.y+20 );
    SetClientSize( size.x+20, size.y+20 );
}

SimpleTransientPopup::~SimpleTransientPopup()
{
}

void SimpleTransientPopup::Popup(wxWindow *focus)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::Popup"), int(this) );
    wxPopupTransientWindow::Popup(focus);
}

void SimpleTransientPopup::OnDismiss()
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnDismiss"), int(this) );
    wxPopupTransientWindow::OnDismiss();
}

bool SimpleTransientPopup::ProcessLeftDown(wxMouseEvent& event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::ProcessLeftDown pos(%d, %d)"), int(this), event.GetX(), event.GetY());
    return wxPopupTransientWindow::ProcessLeftDown(event);
}
bool SimpleTransientPopup::Show( bool show )
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::Show %d"), int(this), int(show));
    return wxPopupTransientWindow::Show(show);
}

void SimpleTransientPopup::OnSize(wxSizeEvent &event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSize"), int(this) );
    event.Skip();
}

void SimpleTransientPopup::OnSetFocus(wxFocusEvent &event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSetFocus"), int(this) );
    event.Skip();
}

void SimpleTransientPopup::OnKillFocus(wxFocusEvent &event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnKillFocus"), int(this) );
    event.Skip();
}

void SimpleTransientPopup::OnMouse(wxMouseEvent &event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnMouse pos(%d, %d)"), int(this), event.GetX(), event.GetY());
    event.Skip();
}

void SimpleTransientPopup::OnButton(wxCommandEvent& event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnButton ID %d"), int(this), event.GetId());

    wxButton *button = wxDynamicCast(event.GetEventObject(), wxButton);
    if (button->GetLabel() == wxT("Press Me"))
        button->SetLabel(wxT("Pressed"));
    else
        button->SetLabel(wxT("Press Me"));

    event.Skip();
}

void SimpleTransientPopup::OnSpinCtrl(wxSpinEvent& event)
{
    wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSpinCtrl ID %d Value %d"), int(this), event.GetId(), event.GetInt());
    event.Skip();
}

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

class MyDialog : public wxDialog
{
public:
    MyDialog(const wxString& title);

    void OnStartSimplePopup(wxCommandEvent& event);
    void OnStartScrolledPopup(wxCommandEvent& event);

private:
    DECLARE_EVENT_TABLE()
};

class MyFrame : public wxFrame
{
public:
    MyFrame(const wxString& title);
    virtual ~MyFrame();

    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
    void OnTestDialog(wxCommandEvent& event);
    void OnStartSimplePopup(wxCommandEvent& event);
    void OnStartScrolledPopup(wxCommandEvent& event);

private:
    wxTextCtrl *m_logWin;
    wxLog *m_logOld;
    DECLARE_EVENT_TABLE()
};

class MyApp : public wxApp
{
public:
    virtual bool OnInit();

    MyFrame *m_frame;
};

// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------


IMPLEMENT_APP(MyApp)

// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
    // create the main application window
    m_frame = new MyFrame(_T("Popup wxWidgets App"));

    // and show it (the frames, unlike simple controls, are not shown when
    // created initially)
    m_frame->Show(true);

    // success: wxApp::OnRun() will be called which will enter the main message
    // loop and the application will run. If we returned false here, the
    // application would exit immediately.
    return true;
}

// ----------------------------------------------------------------------------
// main frame
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(Minimal_Quit,  MyFrame::OnQuit)
    EVT_MENU(Minimal_About, MyFrame::OnAbout)
    EVT_MENU(Minimal_TestDialog, MyFrame::OnTestDialog)
    EVT_BUTTON(Minimal_StartSimplePopup, MyFrame::OnStartSimplePopup)
    EVT_BUTTON(Minimal_StartScrolledPopup, MyFrame::OnStartScrolledPopup)
END_EVENT_TABLE()

MyFrame::MyFrame(const wxString& title)
       : wxFrame(NULL, wxID_ANY, title)
{
    SetIcon(wxICON(sample));

#if wxUSE_MENUS
    wxMenu *menuFile = new wxMenu;

    // the "About" item should be in the help menu
    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append(Minimal_About, _T("&About...\tF1"), _T("Show about dialog"));

    menuFile->Append(Minimal_TestDialog, _T("&Test dialog\tAlt-T"), _T("Test dialog"));
    menuFile->Append(Minimal_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));

    // now append the freshly created menu to the menu bar...
    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(menuFile, _T("&File"));
    menuBar->Append(helpMenu, _T("&Help"));

    // ... and attach this menu bar to the frame
    SetMenuBar(menuBar);
#endif // wxUSE_MENUS

    wxButton *button1 = new wxButton( this, Minimal_StartSimplePopup, wxT("Show simple popup"), wxPoint(20,20) );
    wxButton *button2 = new wxButton( this, Minimal_StartScrolledPopup, wxT("Show scrolled popup"), wxPoint(20,70) );

    m_logWin = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
                             wxDefaultSize, wxTE_MULTILINE );
    m_logWin->SetEditable(false);
    wxLogTextCtrl* logger = new wxLogTextCtrl( m_logWin );
    m_logOld = logger->SetActiveTarget( logger );
    logger->SetTimestamp( NULL );

    wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
    topSizer->Add( button1, 0 );
    topSizer->Add( button2, 0 );
    topSizer->Add( m_logWin, 1, wxEXPAND );

    SetAutoLayout( true );
    SetSizer( topSizer );

#if wxUSE_STATUSBAR
    // create a status bar just for fun (by default with 1 pane only)
    CreateStatusBar(2);
    SetStatusText(_T("Welcome to wxWidgets!"));
#endif // wxUSE_STATUSBAR
}

MyFrame::~MyFrame()
{
    delete wxLog::SetActiveTarget(m_logOld);
}


// event handlers

void MyFrame::OnStartSimplePopup(wxCommandEvent& event)
{
    wxLogMessage( wxT("================================================") );
    SimpleTransientPopup* popup = new SimpleTransientPopup( this );
    wxWindow *btn = (wxWindow*) event.GetEventObject();
    wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
    wxSize sz = btn->GetSize();
    popup->Position( pos, sz );
    wxLogMessage( wxT("0x%x Simple Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
    popup->Popup();
}

void MyFrame::OnStartScrolledPopup(wxCommandEvent& event)
{
    wxLogMessage( wxT("================================================") );
    SimpleTransientPopup* popup = new SimpleTransientPopup( this );
    popup->GetChild()->SetScrollbars(1, 1, 1000, 1000);
    wxWindow *btn = (wxWindow*) event.GetEventObject();
    wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
    wxSize sz = btn->GetSize();
    popup->Position( pos, sz );
    wxLogMessage( wxT("0x%x Scrolled Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
    popup->Popup();
}

void MyFrame::OnTestDialog(wxCommandEvent& WXUNUSED(event))
{
    MyDialog dialog( wxT("Test") );
    dialog.ShowModal();
}

void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    // true is to force the frame to close
    Close(true);
}

void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxString msg;
    msg.Printf( _T("This is the About dialog of the popup sample.\n")
                _T("Welcome to %s"), wxVERSION_STRING);

    wxMessageBox(msg, _T("About Popup"), wxOK | wxICON_INFORMATION, this);
}

// ----------------------------------------------------------------------------
// test dialog
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(MyDialog, wxDialog)
    EVT_BUTTON(Minimal_StartSimplePopup, MyDialog::OnStartSimplePopup)
    EVT_BUTTON(Minimal_StartScrolledPopup, MyDialog::OnStartScrolledPopup)
END_EVENT_TABLE()

MyDialog::MyDialog(const wxString& title)
       : wxDialog(NULL, wxID_ANY, title, wxPoint(50,50), wxSize(400,300))
{

    new wxButton( this, Minimal_StartSimplePopup, wxT("Show simple popup"), wxPoint(20,20) );
    new wxButton( this, Minimal_StartScrolledPopup, wxT("Show scrolled popup"), wxPoint(20,60) );

    new wxButton( this, wxID_OK, wxT("OK"), wxPoint(20,200) );
}

void MyDialog::OnStartSimplePopup(wxCommandEvent& event)
{
    wxLogMessage( wxT("================================================") );
    SimpleTransientPopup* popup = new SimpleTransientPopup( this );
    wxWindow *btn = (wxWindow*) event.GetEventObject();
    wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
    wxSize sz = btn->GetSize();
    popup->Position( pos, sz );
    wxLogMessage( wxT("0x%x Dialog Simple Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
    popup->Popup();
}

void MyDialog::OnStartScrolledPopup(wxCommandEvent& event)
{
    wxLogMessage( wxT("================================================") );
    SimpleTransientPopup* popup = new SimpleTransientPopup( this );
    popup->GetChild()->SetScrollbars(1, 1, 1000, 1000);
    wxWindow *btn = (wxWindow*) event.GetEventObject();
    wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
    wxSize sz = btn->GetSize();
    popup->Position( pos, sz );
    wxLogMessage( wxT("0x%x Dialog Scrolled Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
    popup->Popup();
}
Commit	Line	Data
98d5b42b RR	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: minimal.cpp
	3	// Purpose: Popup wxWidgets sample
43f813d1	4	// Author: Robert Roebling
98d5b42b	5	// Modified by:
43f813d1	6	// Created: 2005-02-04
98d5b42b	7	// RCS-ID: $Id$
43f813d1	8	// Copyright: (c) 2005 Robert Roebling
98d5b42b RR	9	// Licence: wxWindows licence
	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 (this file is usually all you
	28	// need because it includes almost all "standard" wxWidgets headers)
	29	#ifndef WX_PRECOMP
	30	#include "wx/wx.h"
	31	#endif
	32
	33	#include "wx/popupwin.h"
b6de8445	34	#include "wx/spinctrl.h"
98d5b42b RR	35
	36	// ----------------------------------------------------------------------------
	37	// resources
	38	// ----------------------------------------------------------------------------
	39
	40	// the application icon (under Windows and OS/2 it is in resources and even
	41	// though we could still include the XPM here it would be unused)
	42	#if !defined(__WXMSW__) && !defined(__WXPM__)
	43	#include "../sample.xpm"
	44	#endif
	45
b6de8445 RR	46	// ----------------------------------------------------------------------------
	47	// constants
	48	// ----------------------------------------------------------------------------
	49
	50	// IDs for the controls and the menu commands
	51	enum
	52	{
	53	Minimal_Quit = wxID_EXIT,
	54	Minimal_About = wxID_ABOUT,
	55	Minimal_TestDialog,
	56	Minimal_StartSimplePopup,
	57	Minimal_StartScrolledPopup,
	58	Minimal_LogWindow,
	59	Minimal_PopupButton,
	60	Minimal_PopupSpinctrl
	61	};
	62
34786588 VZ	63	//----------------------------------------------------------------------------
	64	// SimpleTransientPopup
	65	//----------------------------------------------------------------------------
98d5b42b RR	66	class SimpleTransientPopup: public wxPopupTransientWindow
	67	{
	68	public:
	69	SimpleTransientPopup( wxWindow *parent );
	70	virtual ~SimpleTransientPopup();
34786588 VZ	71
	72	// wxPopupTransientWindow virtual methods are all overridden to log them
	73	virtual void Popup(wxWindow *focus = NULL);
	74	virtual void OnDismiss();
	75	virtual bool ProcessLeftDown(wxMouseEvent& event);
	76	virtual bool Show( bool show = true );
dd6a7fb4	77
34786588	78	wxScrolledWindow* GetChild() { return m_panel; }
dd6a7fb4	79
98d5b42b	80	private:
34786588	81	wxScrolledWindow *m_panel;
b6de8445 RR	82	wxButton *m_button;
b6de8445 RR	83	wxSpinCtrl *m_spinCtrl;
dd6a7fb4	84
98d5b42b RR	85	private:
	86	void OnMouse( wxMouseEvent &event );
	87	void OnSize( wxSizeEvent &event );
	88	void OnSetFocus( wxFocusEvent &event );
	89	void OnKillFocus( wxFocusEvent &event );
b6de8445 RR	90	void OnButton( wxCommandEvent& event );
b6de8445 RR	91	void OnSpinCtrl( wxSpinEvent& event );
98d5b42b RR	92
	93	private:
	94	DECLARE_CLASS(SimpleTransientPopup)
	95	DECLARE_EVENT_TABLE()
	96	};
	97
98d5b42b RR	98	//----------------------------------------------------------------------------
	99	// SimpleTransientPopup
	100	//----------------------------------------------------------------------------
98d5b42b RR	101	IMPLEMENT_CLASS(SimpleTransientPopup,wxPopupTransientWindow)
	102
	103	BEGIN_EVENT_TABLE(SimpleTransientPopup,wxPopupTransientWindow)
	104	EVT_MOUSE_EVENTS( SimpleTransientPopup::OnMouse )
	105	EVT_SIZE( SimpleTransientPopup::OnSize )
	106	EVT_SET_FOCUS( SimpleTransientPopup::OnSetFocus )
	107	EVT_KILL_FOCUS( SimpleTransientPopup::OnKillFocus )
b6de8445 RR	108	EVT_BUTTON( Minimal_PopupButton, SimpleTransientPopup::OnButton )
b6de8445 RR	109	EVT_SPINCTRL( Minimal_PopupSpinctrl, SimpleTransientPopup::OnSpinCtrl )
98d5b42b RR	110	END_EVENT_TABLE()
	111
	112	SimpleTransientPopup::SimpleTransientPopup( wxWindow *parent ) :
	113	wxPopupTransientWindow( parent )
	114	{
dd6a7fb4	115	m_panel = new wxScrolledWindow( this, wxID_ANY );
98d5b42b	116	m_panel->SetBackgroundColour( *wxLIGHT_GREY );
dd6a7fb4	117	wxStaticText *text = new wxStaticText( m_panel, wxID_ANY,
98d5b42b RR	118	wxT("wx.PopupTransientWindow is a\n")
	119	wxT("wx.PopupWindow which disappears\n")
	120	wxT("automatically when the user\n")
	121	wxT("clicks the mouse outside it or if it\n")
	122	wxT("(or its first child) loses focus in \n")
	123	wxT("any other way."), wxPoint( 10,10) );
	124	wxSize size = text->GetBestSize();
b6de8445 RR	125
	126	m_button = new wxButton(m_panel, Minimal_PopupButton, wxT("Press Me"), wxPoint(0, size.y + 10));
	127	size.y = m_button->GetRect().GetBottom();
	128	m_spinCtrl = new wxSpinCtrl(m_panel, Minimal_PopupSpinctrl, wxT("Hello"), wxPoint(0, size.y + 5));
	129	size.y = m_spinCtrl->GetRect().GetBottom();
21fe01e2	130
98d5b42b RR	131	m_panel->SetSize( size.x+20, size.y+20 );
	132	SetClientSize( size.x+20, size.y+20 );
	133	}
	134
	135	SimpleTransientPopup::~SimpleTransientPopup()
	136	{
	137	}
	138
34786588 VZ	139	void SimpleTransientPopup::Popup(wxWindow *focus)
34786588 VZ	140	{
21fe01e2	141	wxLogMessage( wxT("0x%x SimpleTransientPopup::Popup"), int(this) );
34786588 VZ	142	wxPopupTransientWindow::Popup(focus);
	143	}
	144
98d5b42b RR	145	void SimpleTransientPopup::OnDismiss()
98d5b42b RR	146	{
21fe01e2	147	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnDismiss"), int(this) );
34786588 VZ	148	wxPopupTransientWindow::OnDismiss();
	149	}
	150
	151	bool SimpleTransientPopup::ProcessLeftDown(wxMouseEvent& event)
	152	{
21fe01e2	153	wxLogMessage( wxT("0x%x SimpleTransientPopup::ProcessLeftDown pos(%d, %d)"), int(this), event.GetX(), event.GetY());
34786588 VZ	154	return wxPopupTransientWindow::ProcessLeftDown(event);
	155	}
	156	bool SimpleTransientPopup::Show( bool show )
	157	{
21fe01e2	158	wxLogMessage( wxT("0x%x SimpleTransientPopup::Show %d"), int(this), int(show));
34786588	159	return wxPopupTransientWindow::Show(show);
98d5b42b RR	160	}
	161
	162	void SimpleTransientPopup::OnSize(wxSizeEvent &event)
	163	{
21fe01e2	164	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSize"), int(this) );
98d5b42b RR	165	event.Skip();
	166	}
	167
	168	void SimpleTransientPopup::OnSetFocus(wxFocusEvent &event)
	169	{
21fe01e2	170	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSetFocus"), int(this) );
43f813d1	171	event.Skip();
98d5b42b RR	172	}
	173
	174	void SimpleTransientPopup::OnKillFocus(wxFocusEvent &event)
	175	{
21fe01e2	176	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnKillFocus"), int(this) );
43f813d1	177	event.Skip();
98d5b42b RR	178	}
	179
	180	void SimpleTransientPopup::OnMouse(wxMouseEvent &event)
	181	{
21fe01e2	182	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnMouse pos(%d, %d)"), int(this), event.GetX(), event.GetY());
34786588 VZ	183	event.Skip();
	184	}
	185
b6de8445	186	void SimpleTransientPopup::OnButton(wxCommandEvent& event)
34786588	187	{
21fe01e2	188	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnButton ID %d"), int(this), event.GetId());
dd6a7fb4	189
b6de8445 RR	190	wxButton *button = wxDynamicCast(event.GetEventObject(), wxButton);
	191	if (button->GetLabel() == wxT("Press Me"))
	192	button->SetLabel(wxT("Pressed"));
dd6a7fb4	193	else
b6de8445	194	button->SetLabel(wxT("Press Me"));
34786588	195
34786588 VZ	196	event.Skip();
34786588 VZ	197	}
34786588	198
b6de8445	199	void SimpleTransientPopup::OnSpinCtrl(wxSpinEvent& event)
34786588	200	{
21fe01e2	201	wxLogMessage( wxT("0x%x SimpleTransientPopup::OnSpinCtrl ID %d Value %d"), int(this), event.GetId(), event.GetInt());
98d5b42b RR	202	event.Skip();
	203	}
	204
	205	// ----------------------------------------------------------------------------
	206	// private classes
	207	// ----------------------------------------------------------------------------
	208
98d5b42b RR	209	class MyDialog : public wxDialog
	210	{
	211	public:
	212	MyDialog(const wxString& title);
	213
	214	void OnStartSimplePopup(wxCommandEvent& event);
34786588	215	void OnStartScrolledPopup(wxCommandEvent& event);
98d5b42b RR	216
	217	private:
	218	DECLARE_EVENT_TABLE()
	219	};
	220
	221	class MyFrame : public wxFrame
	222	{
	223	public:
	224	MyFrame(const wxString& title);
34786588 VZ	225	virtual ~MyFrame();
34786588 VZ	226
98d5b42b RR	227	void OnQuit(wxCommandEvent& event);
	228	void OnAbout(wxCommandEvent& event);
	229	void OnTestDialog(wxCommandEvent& event);
	230	void OnStartSimplePopup(wxCommandEvent& event);
34786588	231	void OnStartScrolledPopup(wxCommandEvent& event);
98d5b42b RR	232
98d5b42b RR	233	private:
b6de8445	234	wxTextCtrl *m_logWin;
34786588	235	wxLog *m_logOld;
98d5b42b RR	236	DECLARE_EVENT_TABLE()
	237	};
	238
b6de8445	239	class MyApp : public wxApp
98d5b42b	240	{
b6de8445 RR	241	public:
	242	virtual bool OnInit();
	243
	244	MyFrame *m_frame;
98d5b42b RR	245	};
	246
	247	// ----------------------------------------------------------------------------
	248	// event tables and other macros for wxWidgets
	249	// ----------------------------------------------------------------------------
	250
	251
	252	IMPLEMENT_APP(MyApp)
	253
	254	// 'Main program' equivalent: the program execution "starts" here
	255	bool MyApp::OnInit()
	256	{
	257	// create the main application window
b6de8445	258	m_frame = new MyFrame(_T("Popup wxWidgets App"));
98d5b42b RR	259
	260	// and show it (the frames, unlike simple controls, are not shown when
	261	// created initially)
b6de8445	262	m_frame->Show(true);
98d5b42b RR	263
	264	// success: wxApp::OnRun() will be called which will enter the main message
	265	// loop and the application will run. If we returned false here, the
	266	// application would exit immediately.
	267	return true;
	268	}
	269
	270	// ----------------------------------------------------------------------------
	271	// main frame
	272	// ----------------------------------------------------------------------------
	273
	274	BEGIN_EVENT_TABLE(MyFrame, wxFrame)
	275	EVT_MENU(Minimal_Quit, MyFrame::OnQuit)
	276	EVT_MENU(Minimal_About, MyFrame::OnAbout)
	277	EVT_MENU(Minimal_TestDialog, MyFrame::OnTestDialog)
	278	EVT_BUTTON(Minimal_StartSimplePopup, MyFrame::OnStartSimplePopup)
34786588	279	EVT_BUTTON(Minimal_StartScrolledPopup, MyFrame::OnStartScrolledPopup)
98d5b42b RR	280	END_EVENT_TABLE()
	281
	282	MyFrame::MyFrame(const wxString& title)
	283	: wxFrame(NULL, wxID_ANY, title)
	284	{
	285	SetIcon(wxICON(sample));
	286
	287	#if wxUSE_MENUS
	288	wxMenu *menuFile = new wxMenu;
	289
	290	// the "About" item should be in the help menu
	291	wxMenu *helpMenu = new wxMenu;
	292	helpMenu->Append(Minimal_About, _T("&About...\tF1"), _T("Show about dialog"));
	293
	294	menuFile->Append(Minimal_TestDialog, _T("&Test dialog\tAlt-T"), _T("Test dialog"));
	295	menuFile->Append(Minimal_Quit, _T("E&xit\tAlt-X"), _T("Quit this program"));
	296
	297	// now append the freshly created menu to the menu bar...
	298	wxMenuBar *menuBar = new wxMenuBar();
	299	menuBar->Append(menuFile, _T("&File"));
	300	menuBar->Append(helpMenu, _T("&Help"));
	301
	302	// ... and attach this menu bar to the frame
	303	SetMenuBar(menuBar);
	304	#endif // wxUSE_MENUS
	305
34786588 VZ	306	wxButton *button1 = new wxButton( this, Minimal_StartSimplePopup, wxT("Show simple popup"), wxPoint(20,20) );
34786588 VZ	307	wxButton *button2 = new wxButton( this, Minimal_StartScrolledPopup, wxT("Show scrolled popup"), wxPoint(20,70) );
34786588	308
b6de8445	309	m_logWin = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition,
34786588	310	wxDefaultSize, wxTE_MULTILINE );
b6de8445 RR	311	m_logWin->SetEditable(false);
b6de8445 RR	312	wxLogTextCtrl* logger = new wxLogTextCtrl( m_logWin );
34786588 VZ	313	m_logOld = logger->SetActiveTarget( logger );
34786588 VZ	314	logger->SetTimestamp( NULL );
dd6a7fb4	315
34786588 VZ	316	wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
	317	topSizer->Add( button1, 0 );
	318	topSizer->Add( button2, 0 );
b6de8445	319	topSizer->Add( m_logWin, 1, wxEXPAND );
98d5b42b	320
34786588 VZ	321	SetAutoLayout( true );
34786588 VZ	322	SetSizer( topSizer );
98d5b42b RR	323
	324	#if wxUSE_STATUSBAR
	325	// create a status bar just for fun (by default with 1 pane only)
	326	CreateStatusBar(2);
	327	SetStatusText(_T("Welcome to wxWidgets!"));
	328	#endif // wxUSE_STATUSBAR
	329	}
	330
dd6a7fb4 WS	331	MyFrame::~MyFrame()
	332	{
	333	delete wxLog::SetActiveTarget(m_logOld);
	334	}
34786588 VZ	335
34786588 VZ	336
98d5b42b RR	337	// event handlers
	338
	339	void MyFrame::OnStartSimplePopup(wxCommandEvent& event)
	340	{
b6de8445	341	wxLogMessage( wxT("================================================") );
98d5b42b RR	342	SimpleTransientPopup* popup = new SimpleTransientPopup( this );
	343	wxWindow btn = (wxWindow) event.GetEventObject();
	344	wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
	345	wxSize sz = btn->GetSize();
	346	popup->Position( pos, sz );
b6de8445	347	wxLogMessage( wxT("0x%x Simple Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
98d5b42b RR	348	popup->Popup();
	349	}
	350
34786588	351	void MyFrame::OnStartScrolledPopup(wxCommandEvent& event)
98d5b42b	352	{
34786588	353	wxLogMessage( wxT("================================================") );
b6de8445	354	SimpleTransientPopup* popup = new SimpleTransientPopup( this );
34786588 VZ	355	popup->GetChild()->SetScrollbars(1, 1, 1000, 1000);
	356	wxWindow btn = (wxWindow) event.GetEventObject();
	357	wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
	358	wxSize sz = btn->GetSize();
	359	popup->Position( pos, sz );
b6de8445	360	wxLogMessage( wxT("0x%x Scrolled Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
34786588	361	popup->Popup();
98d5b42b RR	362	}
	363
	364	void MyFrame::OnTestDialog(wxCommandEvent& WXUNUSED(event))
	365	{
	366	MyDialog dialog( wxT("Test") );
	367	dialog.ShowModal();
	368	}
	369
	370	void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
	371	{
	372	// true is to force the frame to close
	373	Close(true);
	374	}
	375
	376	void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
	377	{
	378	wxString msg;
	379	msg.Printf( _T("This is the About dialog of the popup sample.\n")
	380	_T("Welcome to %s"), wxVERSION_STRING);
	381
	382	wxMessageBox(msg, _T("About Popup"), wxOK \| wxICON_INFORMATION, this);
	383	}
	384
	385	// ----------------------------------------------------------------------------
	386	// test dialog
	387	// ----------------------------------------------------------------------------
	388
	389	BEGIN_EVENT_TABLE(MyDialog, wxDialog)
	390	EVT_BUTTON(Minimal_StartSimplePopup, MyDialog::OnStartSimplePopup)
34786588	391	EVT_BUTTON(Minimal_StartScrolledPopup, MyDialog::OnStartScrolledPopup)
98d5b42b RR	392	END_EVENT_TABLE()
	393
	394	MyDialog::MyDialog(const wxString& title)
	395	: wxDialog(NULL, wxID_ANY, title, wxPoint(50,50), wxSize(400,300))
	396	{
	397
	398	new wxButton( this, Minimal_StartSimplePopup, wxT("Show simple popup"), wxPoint(20,20) );
34786588	399	new wxButton( this, Minimal_StartScrolledPopup, wxT("Show scrolled popup"), wxPoint(20,60) );
98d5b42b RR	400
	401	new wxButton( this, wxID_OK, wxT("OK"), wxPoint(20,200) );
	402	}
	403
	404	void MyDialog::OnStartSimplePopup(wxCommandEvent& event)
	405	{
b6de8445	406	wxLogMessage( wxT("================================================") );
98d5b42b RR	407	SimpleTransientPopup* popup = new SimpleTransientPopup( this );
	408	wxWindow btn = (wxWindow) event.GetEventObject();
	409	wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
	410	wxSize sz = btn->GetSize();
	411	popup->Position( pos, sz );
b6de8445	412	wxLogMessage( wxT("0x%x Dialog Simple Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
98d5b42b RR	413	popup->Popup();
	414	}
	415
34786588	416	void MyDialog::OnStartScrolledPopup(wxCommandEvent& event)
98d5b42b	417	{
34786588	418	wxLogMessage( wxT("================================================") );
b6de8445	419	SimpleTransientPopup* popup = new SimpleTransientPopup( this );
34786588 VZ	420	popup->GetChild()->SetScrollbars(1, 1, 1000, 1000);
	421	wxWindow btn = (wxWindow) event.GetEventObject();
	422	wxPoint pos = btn->ClientToScreen( wxPoint(0,0) );
	423	wxSize sz = btn->GetSize();
	424	popup->Position( pos, sz );
b6de8445	425	wxLogMessage( wxT("0x%x Dialog Scrolled Popup Shown pos(%d, %d) size(%d, %d)"), long(popup), pos.x, pos.y, sz.x, sz.y );
34786588	426	popup->Popup();
98d5b42b	427	}