1 /****************************************************************************
2 **
3 ** DQt - D bindings for the Qt Toolkit
4 **
5 ** GNU Lesser General Public License Usage
6 ** This file may be used under the terms of the GNU Lesser
7 ** General Public License version 3 as published by the Free Software
8 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
9 ** packaging of this file. Please review the following information to
10 ** ensure the GNU Lesser General Public License version 3 requirements
11 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
12 **
13 ****************************************************************************/
14 module qt.widgets.sizepolicy;
15 extern(C++):
16
17 import qt.config;
18 import qt.core.flags;
19 import qt.core.global;
20 import qt.core.metatype;
21 import qt.core.namespace;
22 import qt.core.objectdefs;
23 import qt.core.typeinfo;
24 import qt.core.variant;
25 import qt.helpers;
26
27 // gcc < 4.8.0 has problems with init'ing variant members in constexpr ctors
28 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54922
29 /+ #if !defined(Q_CC_GNU) || defined(Q_CC_INTEL) || defined(Q_CC_CLANG) || Q_CC_GNU >= 408
30 # define QT_SIZEPOLICY_CONSTEXPR Q_DECL_CONSTEXPR
31 # if defined(Q_COMPILER_UNIFORM_INIT)
32 # define QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT Q_DECL_CONSTEXPR
33 # endif // uniform-init
34 #endif
35
36 #ifndef QT_SIZEPOLICY_CONSTEXPR
37 # define QT_SIZEPOLICY_CONSTEXPR
38 #endif
39 #ifndef QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT
40 # define QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT
41 #endif
42
43 class QVariant;
44 class QSizePolicy;
45
46 Q_DECL_CONST_FUNCTION inline uint qHash(QSizePolicy key, uint seed = 0) noexcept; +/
47
48 @(QMetaType.Type.QSizePolicy) @Q_RELOCATABLE_TYPE extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QSizePolicy
49 {
50 mixin(Q_GADGET);
51
52 public:
53 enum PolicyFlag {
54 GrowFlag = 1,
55 ExpandFlag = 2,
56 ShrinkFlag = 4,
57 IgnoreFlag = 8
58 }
59
60 enum Policy {
61 Fixed = 0,
62 Minimum = PolicyFlag.GrowFlag,
63 Maximum = PolicyFlag.ShrinkFlag,
64 Preferred = PolicyFlag.GrowFlag | PolicyFlag.ShrinkFlag,
65 MinimumExpanding = PolicyFlag.GrowFlag | PolicyFlag.ExpandFlag,
66 Expanding = PolicyFlag.GrowFlag | PolicyFlag.ShrinkFlag | PolicyFlag.ExpandFlag,
67 Ignored = PolicyFlag.ShrinkFlag | PolicyFlag.GrowFlag | PolicyFlag.IgnoreFlag
68 }
69 /+ Q_ENUM(Policy) +/
70
71 enum ControlType {
72 DefaultType = 0x00000001,
73 ButtonBox = 0x00000002,
74 CheckBox = 0x00000004,
75 ComboBox = 0x00000008,
76 Frame = 0x00000010,
77 GroupBox = 0x00000020,
78 Label = 0x00000040,
79 Line = 0x00000080,
80 LineEdit = 0x00000100,
81 PushButton = 0x00000200,
82 RadioButton = 0x00000400,
83 Slider = 0x00000800,
84 SpinBox = 0x00001000,
85 TabWidget = 0x00002000,
86 ToolButton = 0x00004000
87 }
88 /+ Q_DECLARE_FLAGS(ControlTypes, ControlType) +/
89 alias ControlTypes = QFlags!(ControlType); /+ Q_FLAG(ControlTypes) +/
90
91 @disable this();
92 /+this()/+ noexcept+/
93 {
94 this.data = 0;
95 }+/
96
97 /+ #if defined(Q_COMPILER_UNIFORM_INIT) && !defined(Q_QDOC)
98 QSizePolicy(Policy horizontal, Policy vertical, ControlType type = DefaultType) noexcept
99 : bits{0, 0, quint32(horizontal), quint32(vertical),
100 type == DefaultType ? 0 : toControlTypeFieldValue(type), 0, 0, 0}
101 {}
102 #else +/
103 this(Policy horizontal, Policy vertical, ControlType type = ControlType.DefaultType)/+ noexcept+/
104 {
105 this.data = 0;
106
107 bits.horPolicy = horizontal;
108 bits.verPolicy = vertical;
109 setControlType(type);
110 }
111 /+ #endif +/ // uniform-init
112 Policy horizontalPolicy() const/+ noexcept+/ { return static_cast!(Policy)(bits.horPolicy); }
113 Policy verticalPolicy() const/+ noexcept+/ { return static_cast!(Policy)(bits.verPolicy); }
114 ControlType controlType() const/+ noexcept+/;
115
116 void setHorizontalPolicy(Policy d)/+ noexcept+/ { bits.horPolicy = d; }
117 void setVerticalPolicy(Policy d)/+ noexcept+/ { bits.verPolicy = d; }
118 void setControlType(ControlType type)/+ noexcept+/;
119
120 /+ Qt:: +/qt.core.namespace.Orientations expandingDirections() const/+ noexcept+/ {
121 return ( (verticalPolicy() & PolicyFlag.ExpandFlag) ? /+ Qt:: +/qt.core.namespace.Orientations.Vertical : /+ Qt:: +/qt.core.namespace.Orientations() )
122 | ( (horizontalPolicy() & PolicyFlag.ExpandFlag) ? /+ Qt:: +/qt.core.namespace.Orientations.Horizontal : /+ Qt:: +/qt.core.namespace.Orientations() ) ;
123 }
124
125 void setHeightForWidth(bool b)/+ noexcept+/ { bits.hfw = b; }
126 bool hasHeightForWidth() const/+ noexcept+/ { return !!bits.hfw; }
127 void setWidthForHeight(bool b)/+ noexcept+/ { bits.wfh = b; }
128 bool hasWidthForHeight() const/+ noexcept+/ { return !!bits.wfh; }
129
130 /+bool operator ==(ref const(QSizePolicy) s) const/+ noexcept+/ { return data == s.data; }+/
131 /+bool operator !=(ref const(QSizePolicy) s) const/+ noexcept+/ { return data != s.data; }+/
132
133 /+ friend Q_DECL_CONST_FUNCTION uint qHash(QSizePolicy key, uint seed) noexcept { return qHash(key.data, seed); } +/
134
135 /+auto opCast(T : QVariant)() const;+/
136
137 int horizontalStretch() const/+ noexcept+/ { return static_cast!(int)(bits.horStretch); }
138 int verticalStretch() const/+ noexcept+/ { return static_cast!(int)(bits.verStretch); }
139 void setHorizontalStretch(int stretchFactor) { bits.horStretch = static_cast!(quint32)(qBound(0, stretchFactor, 255)); }
140 void setVerticalStretch(int stretchFactor) { bits.verStretch = static_cast!(quint32)(qBound(0, stretchFactor, 255)); }
141
142 // bool retainSizeWhenHidden() const/+ noexcept+/ { return bits.retainSizeWhenHidden; }
143 // void setRetainSizeWhenHidden(bool retainSize)/+ noexcept+/ { bits.retainSizeWhenHidden = retainSize; }
144
145 // void transpose()/+ noexcept+/ { this = transposed(); }
146 /+ Q_REQUIRED_RESULT +/
147 /+ #ifndef Q_QDOC
148 QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT
149 #endif +/
150 /+ QSizePolicy transposed() const/+ noexcept+/
151 {
152 return QSizePolicy(bits.transposed());
153 }+/
154
155 private:
156 version(QT_NO_DATASTREAM){}else
157 {
158 /+ friend Q_WIDGETS_EXPORT QDataStream &operator<<(QDataStream &, const QSizePolicy &); +/
159 /+ friend Q_WIDGETS_EXPORT QDataStream &operator>>(QDataStream &, QSizePolicy &); +/
160 }
161 this(int i)/+ noexcept+/
162 {
163 this.data = i;
164 }
165 /+
166 struct Bits;
167 +/
168 /+/+ explicit +/this(Bits b)/+ noexcept+/
169 {
170 this.bits = b;
171 }+/
172
173 /+ static quint32 toControlTypeFieldValue(ControlType type)/+ noexcept+/
174 {
175 /*
176 The control type is a flag type, with values 0x1, 0x2, 0x4, 0x8, 0x10,
177 etc. In memory, we pack it onto the available bits (CTSize) in
178 setControlType(), and unpack it here.
179
180 Example:
181
182 0x00000001 maps to 0
183 0x00000002 maps to 1
184 0x00000004 maps to 2
185 0x00000008 maps to 3
186 etc.
187 */
188
189 return qCountTrailingZeroBits(static_cast!(quint32)(type));
190 }+/
191
192 struct Bits {
193 /+ quint32 horStretch : 8; +/
194 uint bitfieldData_horStretch;
195 final quint32 horStretch() const
196 {
197 return (bitfieldData_horStretch >> 0) & 0xff;
198 }
199 final uint horStretch(uint value)
200 {
201 bitfieldData_horStretch = (bitfieldData_horStretch & ~0xff) | ((value & 0xff) << 0);
202 return value;
203 }
204 /+ quint32 verStretch : 8; +/
205 final quint32 verStretch() const
206 {
207 return (bitfieldData_horStretch >> 8) & 0xff;
208 }
209 final uint verStretch(uint value)
210 {
211 bitfieldData_horStretch = (bitfieldData_horStretch & ~0xff00) | ((value & 0xff) << 8);
212 return value;
213 }
214 /+ quint32 horPolicy : 4; +/
215 final quint32 horPolicy() const
216 {
217 return (bitfieldData_horStretch >> 16) & 0xf;
218 }
219 final uint horPolicy(uint value)
220 {
221 bitfieldData_horStretch = (bitfieldData_horStretch & ~0xf0000) | ((value & 0xf) << 16);
222 return value;
223 }
224 /+ quint32 verPolicy : 4; +/
225 final quint32 verPolicy() const
226 {
227 return (bitfieldData_horStretch >> 20) & 0xf;
228 }
229 final uint verPolicy(uint value)
230 {
231 bitfieldData_horStretch = (bitfieldData_horStretch & ~0xf00000) | ((value & 0xf) << 20);
232 return value;
233 }
234 /+ quint32 ctype : 5; +/
235 final quint32 ctype() const
236 {
237 return (bitfieldData_horStretch >> 24) & 0x1f;
238 }
239 final uint ctype(uint value)
240 {
241 bitfieldData_horStretch = (bitfieldData_horStretch & ~0x1f000000) | ((value & 0x1f) << 24);
242 return value;
243 }
244 /+ quint32 hfw : 1; +/
245 final quint32 hfw() const
246 {
247 return (bitfieldData_horStretch >> 29) & 0x1;
248 }
249 final uint hfw(uint value)
250 {
251 bitfieldData_horStretch = (bitfieldData_horStretch & ~0x20000000) | ((value & 0x1) << 29);
252 return value;
253 }
254 /+ quint32 wfh : 1; +/
255 final quint32 wfh() const
256 {
257 return (bitfieldData_horStretch >> 30) & 0x1;
258 }
259 final uint wfh(uint value)
260 {
261 bitfieldData_horStretch = (bitfieldData_horStretch & ~0x40000000) | ((value & 0x1) << 30);
262 return value;
263 }
264 /+ quint32 retainSizeWhenHidden : 1; +/
265 final quint32 retainSizeWhenHidden() const
266 {
267 return (bitfieldData_horStretch >> 31) & 0x1;
268 }
269 final uint retainSizeWhenHidden(uint value)
270 {
271 bitfieldData_horStretch = (bitfieldData_horStretch & ~0x80000000) | ((value & 0x1) << 31);
272 return value;
273 }
274
275 /+ QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT +/
276 /+ Bits transposed() const/+ noexcept+/
277 {
278 return Bits(verStretch, // \ swap
279 horStretch, // /
280 verPolicy, // \ swap
281 horPolicy, // /
282 ctype,
283 hfw, // \ don't swap (historic behavior)
284 wfh, // /
285 retainSizeWhenHidden);
286 }+/
287 }
288 union {
289 Bits bits;
290 quint32 data;
291 }
292 }
293 /+ #if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
294 // Can't add in Qt 5, as QList<QSizePolicy> would be BiC:
295 Q_DECLARE_TYPEINFO(QSizePolicy, Q_PRIMITIVE_TYPE);
296 #else
297 Q_DECLARE_TYPEINFO(QSizePolicy, Q_RELOCATABLE_TYPE);
298 #endif +/
299 /+pragma(inline, true) QFlags!(QSizePolicy.ControlTypes.enum_type) operator |(QSizePolicy.ControlTypes.enum_type f1, QSizePolicy.ControlTypes.enum_type f2)/+noexcept+/{return QFlags!(QSizePolicy.ControlTypes.enum_type)(f1)|f2;}+/
300 /+pragma(inline, true) QFlags!(QSizePolicy.ControlTypes.enum_type) operator |(QSizePolicy.ControlTypes.enum_type f1, QFlags!(QSizePolicy.ControlTypes.enum_type) f2)/+noexcept+/{return f2|f1;}+/
301 /+pragma(inline, true) QIncompatibleFlag operator |(QSizePolicy.ControlTypes.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/
302
303 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QSizePolicy::ControlTypes)
304 #ifndef QT_NO_DATASTREAM
305 Q_WIDGETS_EXPORT QDataStream &operator<<(QDataStream &, const QSizePolicy &);
306 Q_WIDGETS_EXPORT QDataStream &operator>>(QDataStream &, QSizePolicy &);
307 #endif
308
309 #ifndef QT_NO_DEBUG_STREAM
310 Q_WIDGETS_EXPORT QDebug operator<<(QDebug dbg, const QSizePolicy &);
311 #endif
312
313
314 #undef QT_SIZEPOLICY_CONSTEXPR
315 #undef QT_SIZEPOLICY_CONSTEXPR_AND_UNIFORM_INIT +/
316
317