1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/////////////////////////////////////////////////////////////////////////////
// Name: statbox.h
// Purpose: interface of wxStaticBox
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@class wxStaticBox
A static box is a rectangle drawn around other windows to denote
a logical grouping of items.
Note that while the previous versions required that windows appearing
inside a static box be created as its siblings (i.e. use the same parent as
the static box itself), since wxWidgets 2.9.1 it is possible to create
them as children of wxStaticBox itself and doing this is strongly
recommended and avoids several different repainting problems that could
happen when creating the other windows as siblings of the box.
So the recommended way to create static box and the controls inside it is:
@code
void MyFrame::CreateControls()
{
wxPanel *panel = new wxPanel(this);
wxStaticBox *box = new wxStaticBox(panel, wxID_ANY, "StaticBox");
new wxStaticText(box, wxID_ANY, "This window is a child of the staticbox");
...
}
@endcode
Creating the windows with the static box parent (i.e. @c panel in the
example above) as parent still works but can result in refresh and repaint
problems.
Also note that there is a specialized wxSizer class (wxStaticBoxSizer) which can
be used as an easier way to pack items into a static box.
@library{wxcore}
@category{ctrl}
@appearance{staticbox}
@see wxStaticText, wxStaticBoxSizer
*/
class wxStaticBox : public wxControl
{
public:
/**
Default constructor
*/
wxStaticBox();
/**
Constructor, creating and showing a static box.
@param parent
Parent window. Must not be @NULL.
@param id
Window identifier. The value wxID_ANY indicates a default value.
@param label
Text to be displayed in the static box, the empty string for no label.
@param pos
Window position.
If ::wxDefaultPosition is specified then a default position is chosen.
@param size
Checkbox size.
If ::wxDefaultSize is specified then a default size is chosen.
@param style
Window style. There are no wxStaticBox-specific styles, but generic
::wxALIGN_LEFT, ::wxALIGN_CENTRE_HORIZONTAL and ::wxALIGN_RIGHT can
be used here to change the position of the static box label when
using wxGTK (these styles are ignored under the other platforms
currently).
@param name
Window name.
@see Create()
*/
wxStaticBox(wxWindow* parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
/**
Constructor for a static box using the given window as label.
This constructor takes a pointer to an arbitrary window (although
usually a wxCheckBox or a wxRadioButton) instead of just the usual text
label and puts this window at the top of the box at the place where the
label would be shown.
The @a label window must be a non-null, fully created window and will
become a child of this wxStaticBox, i.e. it will be owned by this
control and will be deleted when the wxStaticBox itself is deleted.
An example of creating a wxStaticBox with window as a label:
@code
void MyFrame::CreateControls()
{
wxPanel* panel = new wxPanel(this);
wxCheckBox* checkbox = new wxCheckBox(panel, wxID_ANY, "Box checkbox");
wxStaticBox* box = new wxStaticBox(panel, wxID_ANY, checkbox);
...
}
@endcode
Currently this constructor is only available in wxGTK and wxMSW, use
@c wxHAS_WINDOW_LABEL_IN_STATIC_BOX to check whether it can be used at
compile-time.
@since 3.1.1
*/
wxStaticBox(wxWindow* parent, wxWindowID id,
wxWindow* label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
/**
Destructor, destroying the group box.
*/
virtual ~wxStaticBox();
/**
Creates the static box for two-step construction.
See wxStaticBox() for further details.
*/
bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxStaticBoxNameStr);
/**
Creates the static box with the window as a label.
This method can only be called for an object created using its default
constructor.
See the constructor documentation for more details.
Currently this overload is only available in wxGTK and wxMSW, use
@c wxHAS_WINDOW_LABEL_IN_STATIC_BOX to check whether it can be used at
compile-time.
@since 3.1.1
*/
bool Create(wxWindow* parent, wxWindowID id,
wxWindow* label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
/**
Enables or disables the box without affecting its label window, if any.
wxStaticBox overrides wxWindow::Enable() in order to avoid disabling
the control used as a label, if this box is using one. This is done in
order to allow using a wxCheckBox, for example, label and enable or
disable the box according to the state of the checkbox: if disabling
the box also disabled the checkbox in this situation, it would make it
impossible for the user to re-enable the box after disabling it, so the
checkbox stays enabled even if @c box->Enable(false) is called.
However with the actual behaviour, implemented in this overridden
method, the following code (shown using C++11 only for convenience,
this behaviour is not C++11-specific):
@code
auto check = new wxCheckBox(parent, wxID_ANY, "Use the box");
auto box = new wxStaticBox(parent, wxID_ANY, check);
check->Bind(wxEVT_CHECKBOX,
[box](wxCommandEvent& event) {
box->Enable(event.IsChecked());
});
@endcode
does work as expected.
Please note that overriding Enable() to not actually disable this
window itself has two possibly unexpected consequences:
- The box retains its enabled status, i.e. IsEnabled() still returns
@true, after calling @c Enable(false).
- The box children are enabled or disabled when the box is, which can
result in the loss of their original state. E.g. if a box child is
initially disabled, then the box itself is disabled and, finally, the
box is enabled again, this child will end up being enabled too (this
wouldn't happen with any other parent window as its children would
inherit the disabled state from the parent instead of being really
disabled themselves when it is disabled). To avoid this problem,
consider using ::wxEVT_UPDATE_UI to ensure that the child state is
always correct or restoring it manually after re-enabling the box.
*/
virtual bool Enable(bool enable = true);
};
|
