<set var="GTK_SRC" hints="files">
<!-- Generic implementations used by wxGTK: -->
src/generic/accel.cpp
+ src/generic/collpaneg.cpp
src/generic/colrdlgg.cpp
src/generic/dirdlgg.cpp
src/generic/fdrepdlg.cpp
src/gtk/checklst.cpp
src/gtk/choice.cpp
src/gtk/colordlg.cpp
+ src/gtk/collpane.cpp
src/gtk/combobox.cpp
src/gtk/control.cpp
src/gtk/clrpicker.cpp
</set>
<set var="MSW_SRC" hints="files">
+ src/generic/collpaneg.cpp
src/generic/statusbr.cpp
src/generic/prntdlgg.cpp
src/msw/accel.cpp
- Reverted wxBuffered[Paint]DC to pre 2.7.1 state, added
wxAutoBufferedPaintDC and wxAutoBufferedPaintDCFactory.
- Renamed wxProgressDialog::UpdatePulse() to just Pulse()
+- Added wxCollapsiblePane (Francesco Montorsi)
- Added wxSimpleHtmlListBox (Francesco Montorsi)
Unix Ports:
--- /dev/null
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Name: collpane.tex
+%% Purpose: wxCollapsiblePane documentation
+%% Author: Francesco Montorsi
+%% Created: 2006-10-14
+%% RCS-ID: $Id$
+%% Copyright: (c) 2006 Francesco Montorsi
+%% License: wxWindows license
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+
+\section{\class{wxCollapsiblePane}}\label{wxcollapsiblepane}
+
+A collapsable panel is a container with an embedded button-like control which can be
+used by the user to collapse or expand the pane's contents.
+
+\wxheading{Derived from}
+
+\helpref{wxControl}{wxcontrol}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Include files}
+
+<wx/collpane.h>
+
+\wxheading{Window styles}
+
+There are no specific styles for this window.
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{See also}
+
+\helpref{wxPanel}{wxpanel}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+
+
+\membersection{wxCollapsiblePane::wxCollapsiblePane}\label{wxcollapsiblepane}
+
+\func{}{wxCollapsiblePane}{\param{wxWindow *}{parent},\rtfsp
+\param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{label},\rtfsp
+\param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = wxCP\_DEFAULT\_STYLE},\rtfsp
+\param{const wxValidator\& }{validator = wxDefaultValidator},
+\param{const wxString\& }{name = ``collapsiblePane"}}
+
+Initializes the object and calls \helpref{Create}{wxcollapsiblepanecreate} with
+all the parameters.
+
+
+\membersection{wxCollapsiblePane::Create}\label{wxcollapsiblepanecreate}
+
+\func{bool}{Create}{\param{wxWindow *}{parent},\rtfsp
+\param{wxWindowID}{ id},\rtfsp
+\param{const wxString\& }{label},\rtfsp
+\param{const wxPoint\& }{pos = wxDefaultPosition},\rtfsp
+\param{const wxSize\& }{size = wxDefaultSize},\rtfsp
+\param{long}{ style = wxCP\_DEFAULT\_STYLE},\rtfsp
+\param{const wxValidator\& }{validator = wxDefaultValidator},
+\param{const wxString\& }{name = ``colourpickerctrl"}}
+
+\wxheading{Parameters}
+
+\docparam{parent}{Parent window, must not be non-\texttt{NULL}.}
+
+\docparam{id}{The identifier for the control.}
+
+\docparam{label}{The initial label shown in the button which allows the user to expand or collapse the pane window.}
+
+\docparam{pos}{Initial position.}
+
+\docparam{size}{Initial size.}
+
+\docparam{style}{The window style, see {\tt wxCP\_*} flags.}
+
+\docparam{validator}{Validator which can be used for additional date checks.}
+
+\docparam{name}{Control name.}
+
+\wxheading{Return value}
+
+\true if the control was successfully created or \false if creation failed.
+
+
+\membersection{wxCollapsiblePane::IsCollapsed}\label{wxcollapsiblepaneiscollapsed}
+
+\constfunc{bool}{IsCollapsed}{\void}
+
+Returns \true if the pane window is currently hidden.
+
+
+
+\membersection{wxCollapsiblePane::Collapse}\label{wxcollapsiblepanecollapse}
+
+\func{void}{Collapse}{\param{bool }{collapse = true}}
+
+Collapses or expands the pane window.
+
+
+
+\membersection{wxCollapsiblePane::Expand}\label{wxcollapsiblepaneexpand}
+
+\func{void}{Expand}{\void}
+
+Equivalent to {\tt Collapse(false)}.
+
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/collpane.h
+// Purpose: wxCollapsiblePane
+// Author: Francesco Montorsi
+// Modified by:
+// Created: 8/10/2006
+// RCS-ID: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COLLAPSABLE_PANE_H_BASE_
+#define _WX_COLLAPSABLE_PANE_H_BASE_
+
+#include "wx/control.h"
+
+
+// ----------------------------------------------------------------------------
+// wxCollapsiblePaneBase: interface for wxCollapsiblePane
+// ----------------------------------------------------------------------------
+
+#define wxCP_DEFAULT_STYLE (0)
+
+class WXDLLEXPORT wxCollapsiblePaneBase : public wxControl
+{
+public:
+ wxCollapsiblePaneBase() {}
+
+ virtual void Expand()
+ { Collapse(false); }
+
+ virtual void Collapse(bool collapse = true) = 0;
+ virtual bool IsCollapsed() const = 0;
+ virtual wxWindow *GetPane() const = 0;
+
+ virtual wxString GetLabel() const = 0;
+ virtual void SetLabel(const wxString &label) = 0;
+};
+
+
+// ----------------------------------------------------------------------------
+// event types and macros
+// ----------------------------------------------------------------------------
+
+BEGIN_DECLARE_EVENT_TYPES()
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CORE, wxEVT_COMMAND_COLLPANE_CHANGED, 1102)
+END_DECLARE_EVENT_TYPES()
+
+class WXDLLIMPEXP_CORE wxCollapsiblePaneEvent : public wxCommandEvent
+{
+public:
+ wxCollapsiblePaneEvent() {}
+ wxCollapsiblePaneEvent(wxObject *generator, int id, bool collapsed)
+ : wxCommandEvent(wxEVT_COMMAND_COLLPANE_CHANGED, id),
+ m_bCollapsed(collapsed)
+ {
+ SetEventObject(generator);
+ }
+
+ bool GetCollapsed() const { return m_bCollapsed; }
+ void SetCollapsed(bool c) { m_bCollapsed = c; }
+
+
+ // default copy ctor, assignment operator and dtor are ok
+ virtual wxEvent *Clone() const { return new wxCollapsiblePaneEvent(*this); }
+
+private:
+ bool m_bCollapsed;
+
+ DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxCollapsiblePaneEvent)
+};
+
+// ----------------------------------------------------------------------------
+// event types and macros
+// ----------------------------------------------------------------------------
+
+typedef void (wxEvtHandler::*wxCollapsiblePaneEventFunction)(wxCollapsiblePaneEvent&);
+
+#define wxCollapsiblePaneEventHandler(func) \
+ (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxCollapsiblePaneEventFunction, &func)
+
+#define EVT_COLLAPSIBLEPANE_CHANGED(id, fn) \
+ wx__DECLARE_EVT1(wxEVT_COMMAND_COLLPANE_CHANGED, id, wxCollapsiblePaneEventFunction(fn))
+
+
+#if defined(__WXGTK24__)
+ #include "wx/gtk/collpane.h"
+#else
+ #include "wx/generic/collpaneg.h"
+ #define wxCollapsiblePane wxGenericCollapsiblePane
+#endif
+
+#endif
+ // _WX_COLLAPSABLE_PANE_H_BASE_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/generic/collpaneg.h
+// Purpose: wxGenericCollapsiblePane
+// Author: Francesco Montorsi
+// Modified by:
+// Created: 8/10/2006
+// RCS-ID: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COLLAPSABLE_PANE_H_GENERIC_
+#define _WX_COLLAPSABLE_PANE_H_GENERIC_
+
+#include "wx/button.h"
+
+
+// the ID of the wxButton used to collapse/expand the panel
+#define wxCP_BUTTON_ID 12356
+
+// the number of pixels to leave between the button and the static line and
+// between the button and the pane
+#define wxCP_MARGIN 10
+
+// forward declared
+class WXDLLEXPORT wxStaticLine;
+
+// class name
+extern WXDLLEXPORT_DATA(const wxChar) wxGenericCollapsiblePaneNameStr[];
+
+
+
+// ----------------------------------------------------------------------------
+// wxGenericCollapsiblePane
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericCollapsiblePane : public wxCollapsiblePaneBase
+{
+public:
+ wxGenericCollapsiblePane() { Init(); }
+
+ wxGenericCollapsiblePane(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+ const wxValidator& val = wxDefaultValidator,
+ const wxString& name = wxGenericCollapsiblePaneNameStr)
+ {
+ Init();
+
+ Create(parent, winid, label, pos, size, style, val, name);
+ }
+
+ void Init()
+ {
+ m_pButton = NULL;
+ m_pStatLine = NULL;
+ m_pPane = NULL;
+ }
+
+ bool Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+ const wxValidator& val = wxDefaultValidator,
+ const wxString& name = wxGenericCollapsiblePaneNameStr);
+
+
+public: // public API
+
+ void Collapse(bool collapse = true);
+ void SetLabel(const wxString &label);
+
+ bool IsCollapsed() const
+ { return m_pPane==NULL || !m_pPane->IsShown(); }
+ wxWindow *GetPane() const
+ { return m_pPane; }
+ wxString GetLabel() const
+ { return m_strLabel; }
+
+ wxWindow *GetTopLevelParent();
+
+public: // event handlers
+
+ void OnButton(wxCommandEvent &ev);
+ void OnSize(wxSizeEvent &ev);
+
+protected: // internal utils
+
+ void LayoutChildren();
+
+ wxString GetBtnLabel() const;
+ virtual wxSize DoGetBestSize() const;
+
+protected:
+
+ wxButton *m_pButton;
+ wxStaticLine *m_pStatLine;
+ wxWindow *m_pPane;
+
+ // the button label without ">>" or "<<"
+ wxString m_strLabel;
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxGenericCollapsiblePane)
+ DECLARE_EVENT_TABLE()
+};
+
+
+#endif
+ // _WX_COLLAPSABLE_PANE_H_GENERIC_
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/gtk/collpane.h
+// Purpose: wxCollapsiblePane
+// Author: Francesco Montorsi
+// Modified by:
+// Created: 8/10/2006
+// RCS-ID: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows Licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_COLLAPSABLE_PANEL_H_GTK_
+#define _WX_COLLAPSABLE_PANEL_H_GTK_
+
+#include "wx/generic/collpaneg.h"
+
+extern WXDLLEXPORT_DATA(const wxChar) wxCollapsiblePaneNameStr[];
+
+// ----------------------------------------------------------------------------
+// wxCollapsiblePane
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxCollapsiblePane : public wxGenericCollapsiblePane
+{
+public:
+ wxCollapsiblePane() { Init(); }
+
+ wxCollapsiblePane(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+ const wxValidator& val = wxDefaultValidator,
+ const wxString& name = wxCollapsiblePaneNameStr)
+ {
+ Init();
+
+ Create(parent, winid, label, pos, size, style, val, name);
+ }
+
+ void Init()
+ {
+ m_bIgnoreNextChange = false;
+ }
+
+ bool Create(wxWindow *parent,
+ wxWindowID winid,
+ const wxString& label,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize,
+ long style = wxTAB_TRAVERSAL | wxNO_BORDER,
+ const wxValidator& val = wxDefaultValidator,
+ const wxString& name = wxCollapsiblePaneNameStr);
+
+public: // public API
+
+ wxSize DoGetBestSize() const;
+ void Collapse(bool collapse = true);
+ bool IsCollapsed() const;
+ void SetLabel(const wxString &str);
+
+ void OnSize(wxSizeEvent&);
+
+public: // used by GTK callbacks
+
+ bool m_bIgnoreNextChange;
+ wxSize m_szCollapsed;
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxCollapsiblePane)
+ DECLARE_EVENT_TABLE()
+};
+
+
+#endif
+ // _WX_COLLAPSABLE_PANEL_H_GTK_
--- /dev/null
+<?xml version="1.0" ?>
+<makefile>
+
+ <include file="../../build/bakefiles/common_samples.bkl"/>
+
+ <exe id="collpane" template="wx_sample" template_append="wx_append">
+ <sources>collpane.cpp</sources>
+ <wx-lib>core</wx-lib>
+ <wx-lib>base</wx-lib>
+ <win32-res>../sample.rc</win32-res>
+ </exe>
+
+</makefile>
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: collpane.cpp
+// Purpose: wxCollapsiblePane sample
+// Author: Francesco Montorsi
+// Modified by:
+// Created: 14/10/06
+// RCS-ID: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+
+ #include "wx/app.h"
+ #include "wx/frame.h"
+
+ #include "wx/scrolwin.h"
+ #include "wx/menu.h"
+
+ #include "wx/textdlg.h" // for wxGetTextFromUser
+#endif
+
+#include "wx/collpane.h"
+#include "wx/sizer.h"
+#include "wx/stattext.h"
+#include "wx/clrpicker.h"
+#include "wx/filepicker.h"
+#include "wx/fontpicker.h"
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// ID for the menu commands
+enum
+{
+ PANE_COLLAPSE,
+ PANE_EXPAND,
+ PANE_SETLABEL,
+ PANE_SHOWDLG,
+ PANE_QUIT = wxID_EXIT
+};
+
+
+// ----------------------------------------------------------------------------
+// our classes
+// ----------------------------------------------------------------------------
+
+class MyApp: public wxApp
+{
+public:
+ MyApp() { }
+
+ virtual bool OnInit();
+
+ DECLARE_NO_COPY_CLASS(MyApp)
+};
+
+class MyFrame: public wxFrame
+{
+public:
+ MyFrame();
+ virtual ~MyFrame();
+
+ // Menu commands
+ void OnCollapse(wxCommandEvent& event);
+ void OnExpand(wxCommandEvent& event);
+ void OnSetLabel(wxCommandEvent& event);
+ void OnShowDialog(wxCommandEvent& event);
+ void Quit(wxCommandEvent& event);
+
+ // Menu command update functions
+ void UpdateUI(wxUpdateUIEvent& event);
+
+private:
+ wxCollapsiblePane *m_collPane;
+
+ DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(MyFrame)
+};
+
+class MyDialog : public wxDialog
+{
+public:
+ MyDialog(wxFrame *parent);
+ void OnToggleStatus(wxCommandEvent& WXUNUSED(ev));
+
+private:
+ wxCollapsiblePane *m_collPane;
+
+ DECLARE_EVENT_TABLE()
+ DECLARE_NO_COPY_CLASS(MyDialog)
+};
+
+
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// MyApp
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_APP(MyApp)
+
+bool MyApp::OnInit()
+{
+ // create and show the main frame
+ MyFrame* frame = new MyFrame;
+
+ frame->Show(true);
+
+ return true;
+}
+
+// ----------------------------------------------------------------------------
+// MyFrame
+// ----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(MyFrame, wxFrame)
+ EVT_MENU(PANE_COLLAPSE, MyFrame::OnCollapse)
+ EVT_MENU(PANE_EXPAND, MyFrame::OnExpand)
+ EVT_MENU(PANE_SETLABEL, MyFrame::OnSetLabel)
+ EVT_MENU(PANE_SHOWDLG, MyFrame::OnShowDialog)
+ EVT_MENU(PANE_QUIT, MyFrame::Quit)
+
+ EVT_UPDATE_UI(wxID_ANY, MyFrame::UpdateUI)
+END_EVENT_TABLE()
+
+// My frame constructor
+MyFrame::MyFrame()
+ : wxFrame(NULL, wxID_ANY, _T("wxCollapsiblePane sample"),
+ wxDefaultPosition, wxSize(420, 300),
+ wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE)
+{
+#if wxUSE_STATUSBAR
+ CreateStatusBar(2);
+#endif // wxUSE_STATUSBAR
+
+ // Make a menubar
+ wxMenu *paneMenu = new wxMenu;
+ paneMenu->Append(PANE_COLLAPSE, _T("Collapse\tCtrl-C"));
+ paneMenu->Append(PANE_EXPAND, _T("Expand\tCtrl-E"));
+ paneMenu->AppendSeparator();
+ paneMenu->Append(PANE_SETLABEL, _T("Set label...\tCtrl-S"));
+ paneMenu->AppendSeparator();
+ paneMenu->Append(PANE_SHOWDLG, _T("Show dialog...\tCtrl-S"));
+ paneMenu->AppendSeparator();
+ paneMenu->Append(PANE_QUIT);
+
+ wxMenuBar *menuBar = new wxMenuBar;
+ menuBar->Append(paneMenu, _T("&Pane"));
+ SetMenuBar(menuBar);
+
+ m_collPane = new wxCollapsiblePane(this, -1, wxT("test!"));
+ wxWindow *win = m_collPane->GetPane();
+
+ new wxStaticText(win, -1, wxT("Static control with absolute coords"), wxPoint(10,2));
+ new wxStaticText(win, -1, wxT("Yet another one!"), wxPoint(30, 30));
+ new wxTextCtrl(win, -1, wxT("You can place anything you like inside a wxCollapsiblePane"),
+ wxPoint(5, 60), wxSize(300, -1));
+}
+
+MyFrame::~MyFrame()
+{
+}
+
+// menu command handlers
+
+void MyFrame::Quit(wxCommandEvent& WXUNUSED(event) )
+{
+ Close(true);
+}
+
+void MyFrame::OnCollapse(wxCommandEvent& WXUNUSED(event) )
+{
+ m_collPane->Collapse();
+}
+
+void MyFrame::OnExpand(wxCommandEvent& WXUNUSED(event) )
+{
+ m_collPane->Expand();
+}
+
+void MyFrame::OnSetLabel(wxCommandEvent& WXUNUSED(event) )
+{
+ wxString text = wxGetTextFromUser(wxT("Input the new label"));
+ m_collPane->SetLabel(text);
+}
+
+void MyFrame::OnShowDialog(wxCommandEvent& WXUNUSED(event) )
+{
+ MyDialog dlg(this);
+ dlg.ShowModal();
+}
+
+void MyFrame::UpdateUI(wxUpdateUIEvent& event)
+{
+ GetMenuBar()->Enable(PANE_COLLAPSE, !m_collPane->IsCollapsed());
+ GetMenuBar()->Enable(PANE_EXPAND, m_collPane->IsCollapsed());
+}
+
+// ----------------------------------------------------------------------------
+// MyDialog
+// ----------------------------------------------------------------------------
+
+enum
+{
+ PANEDLG_TOGGLESTATUS_BTN = wxID_HIGHEST
+};
+
+BEGIN_EVENT_TABLE(MyDialog, wxDialog)
+ EVT_BUTTON(PANEDLG_TOGGLESTATUS_BTN, MyDialog::OnToggleStatus)
+END_EVENT_TABLE()
+
+MyDialog::MyDialog(wxFrame *parent)
+ : wxDialog(parent, wxID_ANY, wxT("Test dialog"),
+ wxDefaultPosition, wxDefaultSize,
+ wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE )
+{
+ wxSizer *sz = new wxBoxSizer(wxVERTICAL);
+ sz->Add(new wxStaticText(this, -1,
+ wxT("This dialog allows you to test the wxCollapsiblePane control")),
+ 0, wxALL, 5);
+ sz->Add(new wxButton(this, PANEDLG_TOGGLESTATUS_BTN, wxT("Change status")),
+ 1, wxGROW|wxALL, 5);
+
+ m_collPane = new wxCollapsiblePane(this, -1, wxT("Click here for a surprise"));
+ sz->Add(m_collPane, 1, wxGROW|wxALL, 5);
+ sz->Add(new wxTextCtrl(this, -1, wxT("just a test")), 0, wxGROW|wxALL, 5);
+ sz->AddSpacer(10);
+ sz->Add(new wxButton(this, wxID_OK), 0, wxALIGN_RIGHT|wxALL, 5);
+
+ // now add test controls in the collapsible pane
+ wxWindow *win = m_collPane->GetPane();
+ wxSizer *paneSz = new wxGridSizer(2, 2, 5, 5);
+ paneSz->Add(new wxColourPickerCtrl(win, -1), 1, wxGROW|wxALL, 2);
+ paneSz->Add(new wxFontPickerCtrl(win, -1), 1, wxGROW|wxALL, 2);
+ paneSz->Add(new wxFilePickerCtrl(win, -1), 1, wxALL|wxALIGN_CENTER, 2);
+ paneSz->Add(new wxDirPickerCtrl(win, -1), 1, wxALL|wxALIGN_CENTER, 2);
+ win->SetSizer(paneSz);
+ paneSz->SetSizeHints(win);
+
+ SetSizer(sz);
+ sz->SetSizeHints(this);
+}
+
+void MyDialog::OnToggleStatus(wxCommandEvent& WXUNUSED(ev))
+{
+ m_collPane->Collapse(!m_collPane->IsCollapsed());
+}
+
#include "wx/generic/aboutdlgg.h"
#include "wx/hyperlink.h"
+#include "wx/collpane.h"
// ============================================================================
// implementation
bool wxGenericAboutDialog::Create(const wxAboutDialogInfo& info)
{
// TODO: should we use main frame as parent by default here?
- if ( !wxDialog::Create(NULL, wxID_ANY, _("About ") + info.GetName()) )
+ if ( !wxDialog::Create(NULL, wxID_ANY, _("About ") + info.GetName(),
+ wxDefaultPosition, wxDefaultSize, wxRESIZE_BORDER|wxDEFAULT_DIALOG_STYLE) )
return false;
m_sizerText = new wxBoxSizer(wxVERTICAL);
#endif // wxUSE_HYPERLINKCTRL/!wxUSE_HYPERLINKCTRL
}
- // TODO: add licence
+ // add licence
+ wxCollapsiblePane *licensepnl = new wxCollapsiblePane(this, wxID_ANY, wxT("License"));
+
+ new wxStaticText(licensepnl->GetPane(), wxID_ANY, info.GetLicence(),
+ wxDefaultPosition, wxDefaultSize,
+ wxALIGN_CENTRE);
+
+ m_sizerText->Add(licensepnl, wxSizerFlags(1).Expand().Border(wxBOTTOM));
// TODO: add credits (developers, artists, doc writers, translators)
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/generic/collpaneg.cpp
+// Purpose: wxGenericCollapsiblePane
+// Author: Francesco Montorsi
+// Modified By:
+// Created: 8/10/2006
+// Id: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+#include "wx/collpane.h"
+#include "wx/statline.h"
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+const wxChar wxGenericCollapsiblePaneNameStr[] = wxT("genericCollapsiblePane");
+
+//-----------------------------------------------------------------------------
+// wxGenericCollapsiblePane
+//-----------------------------------------------------------------------------
+
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_COLLPANE_CHANGED)
+IMPLEMENT_DYNAMIC_CLASS(wxGenericCollapsiblePane, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxCollapsiblePaneEvent, wxCommandEvent)
+
+BEGIN_EVENT_TABLE(wxGenericCollapsiblePane, wxControl)
+ EVT_BUTTON(wxCP_BUTTON_ID, wxGenericCollapsiblePane::OnButton)
+ EVT_SIZE(wxGenericCollapsiblePane::OnSize)
+END_EVENT_TABLE()
+
+
+bool wxGenericCollapsiblePane::Create( wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& val,
+ const wxString& name)
+{
+ if ( !wxControl::Create(parent, id, pos, size, style, val, name) )
+ return false;
+
+ m_strLabel = label;
+
+ // create children; their size & position is set in OnSize()
+ m_pButton = new wxButton(this, wxCP_BUTTON_ID, GetBtnLabel(), wxPoint(0, 0),
+ wxDefaultSize, wxBU_EXACTFIT);
+ m_pStatLine = new wxStaticLine(this, wxID_ANY);
+ m_pPane = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNO_BORDER);
+
+ // start as collapsed:
+ m_pPane->Hide();
+
+ //CacheBestSize(GetBestSize());
+ return true;
+}
+
+wxSize wxGenericCollapsiblePane::DoGetBestSize() const
+{
+ wxSize sz = m_pButton->GetBestSize();
+
+ // set width
+ sz.SetWidth( sz.GetWidth() + wxCP_MARGIN + m_pStatLine->GetBestSize().GetWidth() );
+ sz.SetWidth( wxMax(sz.GetWidth(), m_pPane->GetBestSize().GetWidth()) );
+
+ // when expanded, we need more vertical space
+ if (!IsCollapsed())
+ sz.SetHeight( sz.GetHeight() + wxCP_MARGIN + m_pPane->GetBestSize().GetHeight() );
+
+ return sz;
+}
+
+wxString wxGenericCollapsiblePane::GetBtnLabel() const
+{
+ if (IsCollapsed())
+ return m_strLabel + wxT(" >>");
+ return m_strLabel + wxT(" <<");
+}
+
+void wxGenericCollapsiblePane::Collapse(bool collapse)
+{
+ // optimization
+ if (IsCollapsed() == collapse)
+ return;
+
+ // update our state
+ m_pPane->Show(!collapse);
+
+ // update button label
+ // NB: this must be done after updating our "state"
+ m_pButton->SetLabel(GetBtnLabel());
+
+ // minimal size has priority over the best size so set here our min size
+ wxSize sz = GetBestSize();
+ SetMinSize(sz);
+ SetSize(sz);
+
+ wxWindow *top = GetTopLevelParent();
+ if (top)
+ {
+ // we've changed our size, thus our top level parent needs to relayout itself
+ top->Layout();
+
+ // FIXME: this makes wxGenericCollapsiblePane behave as the user expect but
+ // maybe there are cases where this is unwanted!
+ if (top->GetSizer())
+#ifdef __WXGTK__
+ // FIXME: the SetSizeHints() call would be required also for GTK+ for the
+ // expanded->collapsed transition.
+ // Unfortunately if we enable this line, then the GTK+ top window
+ // won't always be resized by the SetClientSize() call below!
+ // As a side effect of this dirty fix, the minimal size for the
+ // pane window is not set in GTK+ and the user can hide it shrinking
+ // the "top" window...
+ if (IsCollapsed())
+#endif
+ top->GetSizer()->SetSizeHints(top);
+
+ if (IsCollapsed())
+ {
+ // NB: we need to use SetClientSize() and not SetSize() otherwise the size for
+ // windows like e.g. wxFrames with wxMenubars won't be correctly set
+ top->SetClientSize(sz);
+ }
+ else
+ {
+ // force our parent to "fit", i.e. expand so that it can honour
+ // our minimal size
+ top->Fit();
+ }
+ }
+}
+
+wxWindow *wxGenericCollapsiblePane::GetTopLevelParent()
+{
+ wxWindow *parent = GetParent();
+ while (parent && !parent->IsTopLevel())
+ parent = parent->GetParent();
+
+ return parent;
+}
+
+void wxGenericCollapsiblePane::SetLabel(const wxString &label)
+{
+ m_strLabel = label;
+ m_pButton->SetLabel(GetBtnLabel());
+ m_pButton->SetBestFittingSize();
+
+ LayoutChildren();
+}
+
+void wxGenericCollapsiblePane::LayoutChildren()
+{
+ wxSize btnSz = m_pButton->GetSize();
+
+ // the button position & size are always ok...
+
+ // move & resize the static line
+ m_pStatLine->SetSize(btnSz.GetWidth() + wxCP_MARGIN, btnSz.GetHeight()/2,
+ GetSize().GetWidth() - btnSz.GetWidth() - wxCP_MARGIN, -1,
+ wxSIZE_USE_EXISTING);
+
+ // move & resize the container window
+ m_pPane->SetSize(0, btnSz.GetHeight() + wxCP_MARGIN,
+ GetSize().GetWidth(), GetSize().GetHeight() - btnSz.GetHeight() - wxCP_MARGIN);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// wxGenericCollapsiblePane - event handlers
+//-----------------------------------------------------------------------------
+
+void wxGenericCollapsiblePane::OnButton(wxCommandEvent &WXUNUSED(event))
+{
+ Collapse(!IsCollapsed());
+
+ // this change was generated by the user - send the event
+ wxCollapsiblePaneEvent ev(this, GetId(), IsCollapsed());
+ GetEventHandler()->ProcessEvent(ev);
+}
+
+void wxGenericCollapsiblePane::OnSize(wxSizeEvent& WXUNUSED(event))
+{
+#if 0 // for debug only
+ wxClientDC dc(this);
+ dc.SetPen(*wxBLACK_PEN);
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+ dc.DrawRectangle(wxPoint(0,0), GetSize());
+ dc.SetPen(*wxRED_PEN);
+ dc.DrawRectangle(wxPoint(0,0), GetBestSize());
+#endif
+
+
+ if (!m_pButton || !m_pStatLine || !m_pPane)
+ return; // we need to complete the creation first!
+
+ LayoutChildren();
+
+ // this is very important to make the pane window layout show correctly
+ m_pPane->Layout();
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/gtk/collpane.cpp
+// Purpose: wxCollapsiblePane
+// Author: Francesco Montorsi
+// Modified By:
+// Created: 8/10/2006
+// Id: $Id$
+// Copyright: (c) Francesco Montorsi
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __WXGTK24__
+
+#include "wx/collpane.h"
+#include <gtk/gtkexpander.h>
+#include <gtk/gtk.h>
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+
+/* DEBUG TIMER */
+class myTimer : public wxTimer
+{
+ wxCollapsiblePane *p;
+
+public:
+ myTimer(wxCollapsiblePane *pp) {p=pp;}
+
+ void Notify()
+ {
+ //wxLogDebug(wxT("%d"), p->IsCollapsed());
+
+ wxSize sz = p->GetBestSize();
+ wxLogDebug(wxT("our best size is now: %d-%d"), sz.GetWidth(), sz.GetHeight());
+ }
+};
+
+
+
+const wxChar wxCollapsiblePaneNameStr[] = wxT("CollapsiblePane");
+
+//-----------------------------------------------------------------------------
+// "notify::expanded" signal
+//-----------------------------------------------------------------------------
+
+extern "C" {
+
+static void gtk_collapsiblepane_expanded_callback (GObject *object,
+ GParamSpec *param_spec,
+ wxCollapsiblePane *p)
+{
+ // NB: unlike for the "activate" signal, when this callback is called, if we try to
+ // query the "collapsed" status through p->IsCollapsed(), we get the right value.
+ // I.e. here p->IsCollapsed() will return false if this callback has been called
+ // at the end of a collapsed->expanded transition and viceversa.
+ // Inside the "activate" signal callback p->IsCollapsed() would return the wrong value!
+
+ wxLogDebug("gtk_collapsiblepane_expanded_callback - IsCollapsed says %d", p->IsCollapsed());
+
+ wxSize sz;
+ if (!p->IsCollapsed())
+ {
+ // unfortunately there's no clean way to retrieve the minimal size of the expanded pane
+ // in this handler or in other handlers for the signals generated by user clicks on the
+ // GtkExpander button: p->GetBestSize() or p->GetMinSize() would still return the size for
+ // the collapsed expander even if the collapsed->expanded transition has already been
+ // completed (this because GTK+ queues some resize calls which still must be processed).
+ // So, the only solution to correctly set the size hints for this window is to calculate
+ // the expanded size ourselves, without relying on p->Get[Best|Min]Size:
+ sz = p->GetMinSize();
+ sz.SetWidth( wxMax(sz.GetWidth(), p->GetPane()->GetMinSize().GetWidth()) );
+ sz.SetHeight( sz.GetHeight() + p->GetPane()->GetMinSize().GetHeight() + 10 );
+ }
+ else
+ {
+ // same problem described above: using p->Get[Best|Min]Size() here we would get the size
+ // of the control when it is expanded even if the expanded->collapsed transition should be
+ // complete now...
+ // So, we use the size cached at control-creation time...
+ sz = p->m_szCollapsed;
+ }
+
+ wxLogDebug(wxT("gtk_collapsiblepane_expanded_callback - my min size is now: %d-%d"),
+ sz.GetWidth(), sz.GetHeight());
+
+ // minimal size has priority over the best size so set here our min size
+ p->SetMinSize(sz);
+ p->SetSize(sz);
+
+ wxWindow *top = p->GetTopLevelParent();
+ if (top)
+ {
+ // we've changed our size, thus our top level parent needs to relayout itself
+ top->Layout();
+
+ // FIXME: this makes wxGenericCollapsiblePane behave as the user expect but
+ // maybe there are cases where this is unwanted!
+ if (top->GetSizer())
+#ifdef __WXGTK__
+ // FIXME: the SetSizeHints() call would be required also for GTK+ for the
+ // expanded->collapsed transition.
+ // Unfortunately if we enable this line, then the GTK+ top window
+ // won't always be resized by the SetClientSize() call below!
+ // As a side effect of this dirty fix, the minimal size for the
+ // pane window is not set in GTK+ and the user can hide it shrinking
+ // the "top" window...
+ if (p->IsCollapsed())
+#endif
+ top->GetSizer()->SetSizeHints(top);
+
+ if (p->IsCollapsed())
+ {
+ // NB: we need to use SetClientSize() and not SetSize() otherwise the size for
+ // windows like e.g. wxFrames with wxMenubars won't be correctly set
+ top->SetClientSize(sz);
+ }
+ else
+ {
+ // force our parent to "fit", i.e. expand so that it can honour
+ // our minimal size
+ top->Fit();
+ }
+ }
+
+ if (p->m_bIgnoreNextChange)
+ {
+ // change generated programmatically - do not send an event!
+ p->m_bIgnoreNextChange = false;
+ return;
+ }
+
+ // fire an event
+ wxCollapsiblePaneEvent ev(p, p->GetId(), p->IsCollapsed());
+ p->GetEventHandler()->ProcessEvent(ev);
+}
+}
+
+static void gtk_collapsiblepane_insert_callback( wxWindowGTK* parent, wxWindowGTK* child )
+{
+ // this callback should be used only once to insert the "pane" into
+ // the GtkExpander widget. wxGenericCollapsiblePane::DoAddChild() will check
+ // if it has been called only once (and in any case we would get a warning
+ // from the following call as GtkExpander is a GtkBin and can contain only a
+ // single child!).
+ gtk_container_add (GTK_CONTAINER (parent->m_widget), child->m_widget);
+}
+
+
+//-----------------------------------------------------------------------------
+// wxCollapsiblePane
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxCollapsiblePane, wxGenericCollapsiblePane)
+
+BEGIN_EVENT_TABLE(wxCollapsiblePane, wxGenericCollapsiblePane)
+ EVT_SIZE(wxCollapsiblePane::OnSize)
+END_EVENT_TABLE()
+
+bool wxCollapsiblePane::Create( wxWindow *parent, wxWindowID id,
+ const wxString& label,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& val,
+ const wxString& name)
+{
+ if (gtk_check_version(2,4,0)) {wxASSERT(0);
+ return wxGenericCollapsiblePane::Create(parent, id, label, pos, size, style, val, name);}
+
+ m_needParent = true;
+ m_acceptsFocus = true;
+ m_bIgnoreNextChange = false;
+
+ if (!PreCreation( parent, pos, size ) ||
+ !wxControl::CreateBase(parent, id, pos, size, style, val, name))
+ {
+ wxFAIL_MSG( wxT("wxCollapsiblePane creation failed") );
+ return false;
+ }
+
+ m_widget = gtk_expander_new(label.c_str());
+
+ // see the gtk_collapsiblepane_expanded_callback comments to understand why we connect
+ // to the "notify::expanded" signal instead of the more common "activate" one
+ g_signal_connect(m_widget, "notify::expanded",
+ G_CALLBACK(gtk_collapsiblepane_expanded_callback), this);
+
+ // before creating m_pPane, we need to makesure our own insert callback will be used
+ m_insertCallback = gtk_collapsiblepane_insert_callback;
+
+ // this the real "pane"
+ m_pPane = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNO_BORDER);
+
+ gtk_widget_show( GTK_WIDGET(m_widget) );
+ m_parent->DoAddChild( this );
+
+ PostCreation(size);
+ //SetBestSize(size);
+
+ // remember the size of this control when it's collapsed
+ m_szCollapsed = GetBestSize();
+
+ /*
+ myTimer *t = new myTimer(this);
+ t->Start(2000);
+ */
+
+ return true;
+}
+
+wxSize wxCollapsiblePane::DoGetBestSize() const
+{
+ if (!gtk_check_version(2,4,0))
+ {
+ //return wxControl::DoGetBestSize(); // need not to cache the best size!
+
+ wxASSERT_MSG( m_widget, wxT("DoGetBestSize called before creation") );
+
+ GtkRequisition req;
+ req.width = 2;
+ req.height = 2;
+ (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request )
+ (m_widget, &req );
+
+ wxSize best(req.width, req.height);
+ //CacheBestSize(best);
+ return best;
+ }
+
+ return wxGenericCollapsiblePane::DoGetBestSize();
+}
+
+void wxCollapsiblePane::Collapse(bool collapse)
+{
+ if (!gtk_check_version(2,4,0))
+ {
+ // optimization
+ if (IsCollapsed() == collapse)
+ return;
+
+ // do not send event in next signal handler call
+ m_bIgnoreNextChange = true;
+ gtk_expander_set_expanded(GTK_EXPANDER(m_widget), !collapse);
+ }
+ else
+ wxGenericCollapsiblePane::Collapse(collapse);
+}
+
+bool wxCollapsiblePane::IsCollapsed() const
+{
+ if (!gtk_check_version(2,4,0))
+ return !gtk_expander_get_expanded(GTK_EXPANDER(m_widget));
+
+ return wxGenericCollapsiblePane::IsCollapsed();
+}
+
+void wxCollapsiblePane::SetLabel(const wxString &str)
+{
+ if (!gtk_check_version(2,4,0))
+ gtk_expander_set_label(GTK_EXPANDER(m_widget), str.c_str());
+ else
+ wxGenericCollapsiblePane::SetLabel(str);
+}
+
+void wxCollapsiblePane::OnSize(wxSizeEvent &ev)
+{
+#if 0 // for debug only
+ wxClientDC dc(this);
+ dc.SetPen(*wxBLACK_PEN);
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+ dc.DrawRectangle(wxPoint(0,0), GetSize());
+ dc.SetPen(*wxRED_PEN);
+ dc.DrawRectangle(wxPoint(0,0), GetBestSize());
+#endif
+
+ //wxLogDebug(wxT("wxCollapsiblePane::OnSize"));
+
+ // here we need to resize the pane window otherwise, even if the GtkExpander container
+ // is expanded or shrinked, the pane window won't be updated!
+ m_pPane->SetSize(ev.GetSize());
+
+ // we need to explicitely call m_pPane->Layout() or else it won't correctly relayout
+ // (even if SetAutoLayout(true) has been called on it!)
+ m_pPane->Layout();
+}
+
+#endif // __WXGTK24__
+
projects / wxWidgets.git / commitdiff
