1 /* 2 * DQt - D bindings for the Qt Toolkit 3 * 4 * GNU Lesser General Public License Usage 5 * This file may be used under the terms of the GNU Lesser 6 * General Public License version 3 as published by the Free Software 7 * Foundation and appearing in the file LICENSE.LGPL3 included in the 8 * packaging of this file. Please review the following information to 9 * ensure the GNU Lesser General Public License version 3 requirements 10 * will be met: https://www.gnu.org/licenses/lgpl-3.0.html. 11 */ 12 module qt.widgets.styleoption; 13 extern(C++): 14 15 import qt.config; 16 import qt.core.abstractitemmodel; 17 import qt.core.flags; 18 import qt.core.global; 19 import qt.core.locale; 20 import qt.core.namespace; 21 import qt.core.object; 22 import qt.core.point; 23 import qt.core.rect; 24 import qt.core.size; 25 import qt.core.string; 26 import qt.core.variant; 27 import qt.gui.brush; 28 import qt.gui.color; 29 import qt.gui.font; 30 import qt.gui.fontmetrics; 31 import qt.gui.icon; 32 import qt.gui.palette; 33 import qt.gui.region; 34 import qt.gui.transform; 35 import qt.helpers; 36 import qt.widgets.abstractspinbox; 37 import qt.widgets.frame; 38 import qt.widgets.rubberband; 39 import qt.widgets.slider; 40 import qt.widgets.style; 41 import qt.widgets.tabbar; 42 import qt.widgets.widget; 43 44 /+ #if QT_CONFIG(spinbox) 45 #endif 46 #if QT_CONFIG(slider) 47 #endif 48 #if QT_CONFIG(tabbar) 49 #endif 50 #if QT_CONFIG(tabwidget) 51 #endif 52 #if QT_CONFIG(rubberband) 53 #endif 54 #if QT_CONFIG(itemviews) 55 #endif 56 57 58 59 class QDebug; +/ 60 61 /// Binding for C++ class [QStyleOption](https://doc.qt.io/qt-6/qstyleoption.html). 62 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOption 63 { 64 public: 65 enum OptionType { 66 SO_Default, SO_FocusRect, SO_Button, SO_Tab, SO_MenuItem, 67 SO_Frame, SO_ProgressBar, SO_ToolBox, SO_Header, 68 SO_DockWidget, SO_ViewItem, SO_TabWidgetFrame, 69 SO_TabBarBase, SO_RubberBand, SO_ToolBar, SO_GraphicsItem, 70 71 SO_Complex = 0xf0000, SO_Slider, SO_SpinBox, SO_ToolButton, SO_ComboBox, 72 SO_TitleBar, SO_GroupBox, SO_SizeGrip, 73 74 SO_CustomBase = 0xf00, 75 SO_ComplexCustomBase = 0xf000000 76 } 77 78 enum StyleOptionType { Type = OptionType.SO_Default } 79 enum StyleOptionVersion { Version = 1 } 80 81 int version_; 82 int type; 83 QStyle.State state; 84 /+ Qt:: +/qt.core.namespace.LayoutDirection direction; 85 QRect rect; 86 QFontMetrics fontMetrics; 87 QPalette palette; 88 QObject styleObject; 89 90 @disable this(); 91 this(int version_/+ = StyleOptionVersion.Version+/, int type = OptionType.SO_Default); 92 @disable this(this); 93 this(ref const(QStyleOption) other); 94 ~this(); 95 96 mixin(changeWindowsMangling(q{mangleClassesTailConst}, q{ 97 void initFrom(const(QWidget) w); 98 })); 99 /+ref QStyleOption operator =(ref const(QStyleOption) other);+/ 100 mixin(CREATE_CONVENIENCE_WRAPPERS); 101 } 102 103 /// Binding for C++ class [QStyleOptionFocusRect](https://doc.qt.io/qt-6/qstyleoptionfocusrect.html). 104 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionFocusRect 105 { 106 public QStyleOption base0; 107 alias base0 this; 108 alias OptionType = QStyleOption.OptionType; 109 public: 110 enum StyleOptionType { Type = OptionType.SO_FocusRect } 111 enum StyleOptionVersion { Version = 1 } 112 113 QColor backgroundColor; 114 115 @disable this(); 116 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 117 ref typeof(this) rawConstructor(); 118 static typeof(this) create() 119 { 120 typeof(this) r = typeof(this).init; 121 r.rawConstructor(); 122 return r; 123 } 124 125 @disable this(this); 126 this(ref const(QStyleOptionFocusRect) other) 127 { 128 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 129 this = other; 130 } 131 /+ QStyleOptionFocusRect &operator=(const QStyleOptionFocusRect &) = default; +/ 132 133 protected: 134 this(int version_); 135 mixin(CREATE_CONVENIENCE_WRAPPERS); 136 } 137 138 /// Binding for C++ class [QStyleOptionFrame](https://doc.qt.io/qt-6/qstyleoptionframe.html). 139 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionFrame 140 { 141 public QStyleOption base0; 142 alias base0 this; 143 alias OptionType = QStyleOption.OptionType; 144 public: 145 enum StyleOptionType { Type = OptionType.SO_Frame } 146 enum StyleOptionVersion { Version = 1 } 147 148 int lineWidth; 149 int midLineWidth; 150 enum FrameFeature { 151 None = 0x00, 152 Flat = 0x01, 153 Rounded = 0x02 154 } 155 /+ Q_DECLARE_FLAGS(FrameFeatures, FrameFeature) +/ 156 alias FrameFeatures = QFlags!(FrameFeature); FrameFeatures features; 157 QFrame.Shape frameShape; 158 159 @disable this(); 160 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 161 ref typeof(this) rawConstructor(); 162 static typeof(this) create() 163 { 164 typeof(this) r = typeof(this).init; 165 r.rawConstructor(); 166 return r; 167 } 168 169 @disable this(this); 170 this(ref const(QStyleOptionFrame) other) 171 { 172 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 173 this = other; 174 } 175 /+ QStyleOptionFrame &operator=(const QStyleOptionFrame &) = default; +/ 176 177 protected: 178 this(int version_); 179 mixin(CREATE_CONVENIENCE_WRAPPERS); 180 } 181 /+pragma(inline, true) QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) operator |(QStyleOptionFrame.FrameFeatures.enum_type f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionFrame.FrameFeatures.enum_type)(f1)|f2;}+/ 182 /+pragma(inline, true) QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) operator |(QStyleOptionFrame.FrameFeatures.enum_type f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 183 /+pragma(inline, true) QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) operator &(QStyleOptionFrame.FrameFeatures.enum_type f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionFrame.FrameFeatures.enum_type)(f1)&f2;}+/ 184 /+pragma(inline, true) QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) operator &(QStyleOptionFrame.FrameFeatures.enum_type f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 185 /+pragma(inline, true) void operator +(QStyleOptionFrame.FrameFeatures.enum_type f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/;+/ 186 /+pragma(inline, true) void operator +(QStyleOptionFrame.FrameFeatures.enum_type f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/;+/ 187 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/;+/ 188 /+pragma(inline, true) void operator -(QStyleOptionFrame.FrameFeatures.enum_type f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/;+/ 189 /+pragma(inline, true) void operator -(QStyleOptionFrame.FrameFeatures.enum_type f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/;+/ 190 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionFrame.FrameFeatures.enum_type) f2)/+noexcept+/;+/ 191 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionFrame.FrameFeatures.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 192 /+pragma(inline, true) void operator +(int f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/;+/ 193 /+pragma(inline, true) void operator +(QStyleOptionFrame.FrameFeatures.enum_type f1, int f2)/+noexcept+/;+/ 194 /+pragma(inline, true) void operator -(int f1, QStyleOptionFrame.FrameFeatures.enum_type f2)/+noexcept+/;+/ 195 /+pragma(inline, true) void operator -(QStyleOptionFrame.FrameFeatures.enum_type f1, int f2)/+noexcept+/;+/ 196 197 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionFrame::FrameFeatures) 198 #if QT_CONFIG(tabwidget) +/ 199 /// Binding for C++ class [QStyleOptionTabWidgetFrame](https://doc.qt.io/qt-6/qstyleoptiontabwidgetframe.html). 200 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionTabWidgetFrame 201 { 202 public QStyleOption base0; 203 alias base0 this; 204 alias OptionType = QStyleOption.OptionType; 205 public: 206 enum StyleOptionType { Type = OptionType.SO_TabWidgetFrame } 207 enum StyleOptionVersion { Version = 1 } 208 209 int lineWidth; 210 int midLineWidth; 211 QTabBar.Shape shape; 212 QSize tabBarSize; 213 QSize rightCornerWidgetSize; 214 QSize leftCornerWidgetSize; 215 QRect tabBarRect; 216 QRect selectedTabRect; 217 218 @disable this(); 219 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 220 ref typeof(this) rawConstructor(); 221 static typeof(this) create() 222 { 223 typeof(this) r = typeof(this).init; 224 r.rawConstructor(); 225 return r; 226 } 227 228 @disable this(this); 229 pragma(inline, true) this(ref const(QStyleOptionTabWidgetFrame) other) 230 { 231 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 232 this = other; 233 } 234 /+ QStyleOptionTabWidgetFrame &operator=(const QStyleOptionTabWidgetFrame &) = default; +/ 235 236 protected: 237 this(int version_); 238 mixin(CREATE_CONVENIENCE_WRAPPERS); 239 } 240 241 /+ #endif // QT_CONFIG(tabwidget) 242 243 244 #if QT_CONFIG(tabbar) +/ 245 /// Binding for C++ class [QStyleOptionTabBarBase](https://doc.qt.io/qt-6/qstyleoptiontabbarbase.html). 246 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionTabBarBase 247 { 248 public QStyleOption base0; 249 alias base0 this; 250 alias OptionType = QStyleOption.OptionType; 251 public: 252 enum StyleOptionType { Type = OptionType.SO_TabBarBase } 253 enum StyleOptionVersion { Version = 1 } 254 255 QTabBar.Shape shape; 256 QRect tabBarRect; 257 QRect selectedTabRect; 258 bool documentMode; 259 260 @disable this(); 261 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 262 ref typeof(this) rawConstructor(); 263 static typeof(this) create() 264 { 265 typeof(this) r = typeof(this).init; 266 r.rawConstructor(); 267 return r; 268 } 269 270 @disable this(this); 271 this(ref const(QStyleOptionTabBarBase) other) 272 { 273 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 274 this = other; 275 } 276 /+ QStyleOptionTabBarBase &operator=(const QStyleOptionTabBarBase &) = default; +/ 277 278 protected: 279 this(int version_); 280 mixin(CREATE_CONVENIENCE_WRAPPERS); 281 } 282 283 /+ #endif +/ // QT_CONFIG(tabbar) 284 285 /// Binding for C++ class [QStyleOptionHeader](https://doc.qt.io/qt-6/qstyleoptionheader.html). 286 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionHeader 287 { 288 public QStyleOption base0; 289 alias base0 this; 290 alias OptionType = QStyleOption.OptionType; 291 public: 292 enum StyleOptionType { Type = OptionType.SO_Header } 293 enum StyleOptionVersion { Version = 1 } 294 295 enum SectionPosition { Beginning, Middle, End, OnlyOneSection } 296 enum SelectedPosition { NotAdjacent, NextIsSelected, PreviousIsSelected, 297 NextAndPreviousAreSelected } 298 enum SortIndicator { None, SortUp, SortDown } 299 300 int section; 301 QString text; 302 /+ Qt:: +/qt.core.namespace.Alignment textAlignment; 303 QIcon icon; 304 /+ Qt:: +/qt.core.namespace.Alignment iconAlignment; 305 SectionPosition position; 306 SelectedPosition selectedPosition; 307 SortIndicator sortIndicator; 308 /+ Qt:: +/qt.core.namespace.Orientation orientation; 309 310 @disable this(); 311 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 312 ref typeof(this) rawConstructor(); 313 static typeof(this) create() 314 { 315 typeof(this) r = typeof(this).init; 316 r.rawConstructor(); 317 return r; 318 } 319 320 @disable this(this); 321 this(ref const(QStyleOptionHeader) other) 322 { 323 text = QString.create; 324 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 325 this = other; 326 } 327 /+ QStyleOptionHeader &operator=(const QStyleOptionHeader &) = default; +/ 328 329 protected: 330 this(int version_); 331 mixin(CREATE_CONVENIENCE_WRAPPERS); 332 } 333 334 /// Binding for C++ class [QStyleOptionHeaderV2](https://doc.qt.io/qt-6/qstyleoptionheaderv2.html). 335 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionHeaderV2 336 { 337 public QStyleOptionHeader base0; 338 alias base0 this; 339 alias OptionType = QStyleOption.OptionType; 340 public: 341 enum StyleOptionType { Type = OptionType.SO_Header } 342 enum StyleOptionVersion { Version = 2 } 343 344 @disable this(); 345 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 346 ref typeof(this) rawConstructor(); 347 static typeof(this) create() 348 { 349 typeof(this) r = typeof(this).init; 350 r.rawConstructor(); 351 return r; 352 } 353 354 @disable this(this); 355 this(ref const(QStyleOptionHeaderV2) other) 356 { 357 this.base0 = QStyleOptionHeader(StyleOptionVersion.Version); 358 this = other; 359 } 360 /+ QStyleOptionHeaderV2 &operator=(const QStyleOptionHeaderV2 &) = default; +/ 361 362 /+ Qt::TextElideMode textElideMode:2; +/ 363 uint bitfieldData_textElideMode; 364 final qt.core.namespace.TextElideMode textElideMode() const 365 { 366 return cast(qt.core.namespace.TextElideMode)((bitfieldData_textElideMode >> 0) & 0x3); 367 } 368 final qt.core.namespace.TextElideMode textElideMode(qt.core.namespace.TextElideMode value) 369 { 370 bitfieldData_textElideMode = (bitfieldData_textElideMode & ~0x3) | ((value & 0x3) << 0); 371 return value; 372 } 373 /+ bool isSectionDragTarget:1; +/ 374 final bool isSectionDragTarget() const 375 { 376 return (bitfieldData_textElideMode >> 2) & 0x1; 377 } 378 final bool isSectionDragTarget(bool value) 379 { 380 bitfieldData_textElideMode = (bitfieldData_textElideMode & ~0x4) | ((value & 0x1) << 2); 381 return value; 382 } 383 /+ int unused:29; +/ 384 final int unused() const 385 { 386 return (bitfieldData_textElideMode >> 3) & 0x1fffffff; 387 } 388 final int unused(int value) 389 { 390 bitfieldData_textElideMode = (bitfieldData_textElideMode & ~0xfffffff8) | ((value & 0x1fffffff) << 3); 391 return value; 392 } 393 394 protected: 395 this(int version_); 396 mixin(CREATE_CONVENIENCE_WRAPPERS); 397 } 398 399 /// Binding for C++ class [QStyleOptionButton](https://doc.qt.io/qt-6/qstyleoptionbutton.html). 400 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionButton 401 { 402 public QStyleOption base0; 403 alias base0 this; 404 alias OptionType = QStyleOption.OptionType; 405 public: 406 enum StyleOptionType { Type = OptionType.SO_Button } 407 enum StyleOptionVersion { Version = 1 } 408 409 enum ButtonFeature { None = 0x00, Flat = 0x01, HasMenu = 0x02, DefaultButton = 0x04, 410 AutoDefaultButton = 0x08, CommandLinkButton = 0x10 } 411 /+ Q_DECLARE_FLAGS(ButtonFeatures, ButtonFeature) +/ 412 alias ButtonFeatures = QFlags!(ButtonFeature); 413 ButtonFeatures features; 414 QString text; 415 QIcon icon; 416 QSize iconSize; 417 418 @disable this(); 419 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 420 ref typeof(this) rawConstructor(); 421 static typeof(this) create() 422 { 423 typeof(this) r = typeof(this).init; 424 r.rawConstructor(); 425 return r; 426 } 427 428 @disable this(this); 429 this(ref const(QStyleOptionButton) other) 430 { 431 text = QString.create; 432 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 433 this = other; 434 } 435 /+ QStyleOptionButton &operator=(const QStyleOptionButton &) = default; +/ 436 437 protected: 438 this(int version_); 439 mixin(CREATE_CONVENIENCE_WRAPPERS); 440 } 441 /+pragma(inline, true) QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) operator |(QStyleOptionButton.ButtonFeatures.enum_type f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionButton.ButtonFeatures.enum_type)(f1)|f2;}+/ 442 /+pragma(inline, true) QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) operator |(QStyleOptionButton.ButtonFeatures.enum_type f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 443 /+pragma(inline, true) QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) operator &(QStyleOptionButton.ButtonFeatures.enum_type f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionButton.ButtonFeatures.enum_type)(f1)&f2;}+/ 444 /+pragma(inline, true) QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) operator &(QStyleOptionButton.ButtonFeatures.enum_type f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 445 /+pragma(inline, true) void operator +(QStyleOptionButton.ButtonFeatures.enum_type f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/;+/ 446 /+pragma(inline, true) void operator +(QStyleOptionButton.ButtonFeatures.enum_type f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/;+/ 447 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/;+/ 448 /+pragma(inline, true) void operator -(QStyleOptionButton.ButtonFeatures.enum_type f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/;+/ 449 /+pragma(inline, true) void operator -(QStyleOptionButton.ButtonFeatures.enum_type f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/;+/ 450 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionButton.ButtonFeatures.enum_type) f2)/+noexcept+/;+/ 451 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionButton.ButtonFeatures.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 452 /+pragma(inline, true) void operator +(int f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/;+/ 453 /+pragma(inline, true) void operator +(QStyleOptionButton.ButtonFeatures.enum_type f1, int f2)/+noexcept+/;+/ 454 /+pragma(inline, true) void operator -(int f1, QStyleOptionButton.ButtonFeatures.enum_type f2)/+noexcept+/;+/ 455 /+pragma(inline, true) void operator -(QStyleOptionButton.ButtonFeatures.enum_type f1, int f2)/+noexcept+/;+/ 456 457 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionButton::ButtonFeatures) 458 #if QT_CONFIG(tabbar) +/ 459 /// Binding for C++ class [QStyleOptionTab](https://doc.qt.io/qt-6/qstyleoptiontab.html). 460 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionTab 461 { 462 public QStyleOption base0; 463 alias base0 this; 464 alias OptionType = QStyleOption.OptionType; 465 public: 466 enum StyleOptionType { Type = OptionType.SO_Tab } 467 enum StyleOptionVersion { Version = 1 } 468 469 enum TabPosition { Beginning, Middle, End, OnlyOneTab } 470 enum SelectedPosition { NotAdjacent, NextIsSelected, PreviousIsSelected } 471 enum CornerWidget { NoCornerWidgets = 0x00, LeftCornerWidget = 0x01, 472 RightCornerWidget = 0x02 } 473 enum TabFeature { None = 0x00, HasFrame = 0x01 } 474 /+ Q_DECLARE_FLAGS(CornerWidgets, CornerWidget) +/ 475 alias CornerWidgets = QFlags!(CornerWidget); /+ Q_DECLARE_FLAGS(TabFeatures, TabFeature) +/ 476 alias TabFeatures = QFlags!(TabFeature); 477 QTabBar.Shape shape; 478 QString text; 479 QIcon icon; 480 int row; 481 TabPosition position; 482 SelectedPosition selectedPosition; 483 CornerWidgets cornerWidgets; 484 QSize iconSize; 485 bool documentMode; 486 QSize leftButtonSize; 487 QSize rightButtonSize; 488 TabFeatures features; 489 int tabIndex = -1; 490 491 @disable this(); 492 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 493 ref typeof(this) rawConstructor(); 494 static typeof(this) create() 495 { 496 typeof(this) r = typeof(this).init; 497 r.rawConstructor(); 498 return r; 499 } 500 501 @disable this(this); 502 this(ref const(QStyleOptionTab) other) 503 { 504 text = QString.create(); 505 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 506 this = other; 507 } 508 /+ QStyleOptionTab &operator=(const QStyleOptionTab &) = default; +/ 509 510 protected: 511 this(int version_); 512 mixin(CREATE_CONVENIENCE_WRAPPERS); 513 } 514 /+pragma(inline, true) QFlags!(QStyleOptionTab.CornerWidgets.enum_type) operator |(QStyleOptionTab.CornerWidgets.enum_type f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionTab.CornerWidgets.enum_type)(f1)|f2;}+/ 515 /+pragma(inline, true) QFlags!(QStyleOptionTab.CornerWidgets.enum_type) operator |(QStyleOptionTab.CornerWidgets.enum_type f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 516 /+pragma(inline, true) QFlags!(QStyleOptionTab.CornerWidgets.enum_type) operator &(QStyleOptionTab.CornerWidgets.enum_type f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionTab.CornerWidgets.enum_type)(f1)&f2;}+/ 517 /+pragma(inline, true) QFlags!(QStyleOptionTab.CornerWidgets.enum_type) operator &(QStyleOptionTab.CornerWidgets.enum_type f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 518 /+pragma(inline, true) void operator +(QStyleOptionTab.CornerWidgets.enum_type f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/;+/ 519 /+pragma(inline, true) void operator +(QStyleOptionTab.CornerWidgets.enum_type f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/;+/ 520 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/;+/ 521 /+pragma(inline, true) void operator -(QStyleOptionTab.CornerWidgets.enum_type f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/;+/ 522 /+pragma(inline, true) void operator -(QStyleOptionTab.CornerWidgets.enum_type f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/;+/ 523 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionTab.CornerWidgets.enum_type) f2)/+noexcept+/;+/ 524 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionTab.CornerWidgets.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 525 /+pragma(inline, true) void operator +(int f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/;+/ 526 /+pragma(inline, true) void operator +(QStyleOptionTab.CornerWidgets.enum_type f1, int f2)/+noexcept+/;+/ 527 /+pragma(inline, true) void operator -(int f1, QStyleOptionTab.CornerWidgets.enum_type f2)/+noexcept+/;+/ 528 /+pragma(inline, true) void operator -(QStyleOptionTab.CornerWidgets.enum_type f1, int f2)/+noexcept+/;+/ 529 530 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionTab::CornerWidgets) +/ 531 /+ #endif // QT_CONFIG(tabbar) 532 533 534 #if QT_CONFIG(toolbar) +/ 535 536 /// Binding for C++ class [QStyleOptionToolBar](https://doc.qt.io/qt-6/qstyleoptiontoolbar.html). 537 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionToolBar 538 { 539 public QStyleOption base0; 540 alias base0 this; 541 alias OptionType = QStyleOption.OptionType; 542 public: 543 enum StyleOptionType { Type = OptionType.SO_ToolBar } 544 enum StyleOptionVersion { Version = 1 } 545 enum ToolBarPosition { Beginning, Middle, End, OnlyOne } 546 enum ToolBarFeature { None = 0x0, Movable = 0x1 } 547 /+ Q_DECLARE_FLAGS(ToolBarFeatures, ToolBarFeature) +/ 548 alias ToolBarFeatures = QFlags!(ToolBarFeature); ToolBarPosition positionOfLine; // The toolbar line position 549 ToolBarPosition positionWithinLine; // The position within a toolbar 550 /+ Qt:: +/qt.core.namespace.ToolBarArea toolBarArea; // The toolbar docking area 551 ToolBarFeatures features; 552 int lineWidth; 553 int midLineWidth; 554 @disable this(); 555 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 556 ref typeof(this) rawConstructor(); 557 static typeof(this) create() 558 { 559 typeof(this) r = typeof(this).init; 560 r.rawConstructor(); 561 return r; 562 } 563 564 @disable this(this); 565 this(ref const(QStyleOptionToolBar) other) 566 { 567 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 568 this = other; 569 } 570 /+ QStyleOptionToolBar &operator=(const QStyleOptionToolBar &) = default; +/ 571 572 protected: 573 this(int version_); 574 mixin(CREATE_CONVENIENCE_WRAPPERS); 575 } 576 /+pragma(inline, true) QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) operator |(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type)(f1)|f2;}+/ 577 /+pragma(inline, true) QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) operator |(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 578 /+pragma(inline, true) QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) operator &(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type)(f1)&f2;}+/ 579 /+pragma(inline, true) QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) operator &(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 580 /+pragma(inline, true) void operator +(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/;+/ 581 /+pragma(inline, true) void operator +(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/;+/ 582 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/;+/ 583 /+pragma(inline, true) void operator -(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/;+/ 584 /+pragma(inline, true) void operator -(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/;+/ 585 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionToolBar.ToolBarFeatures.enum_type) f2)/+noexcept+/;+/ 586 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 587 /+pragma(inline, true) void operator +(int f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/;+/ 588 /+pragma(inline, true) void operator +(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, int f2)/+noexcept+/;+/ 589 /+pragma(inline, true) void operator -(int f1, QStyleOptionToolBar.ToolBarFeatures.enum_type f2)/+noexcept+/;+/ 590 /+pragma(inline, true) void operator -(QStyleOptionToolBar.ToolBarFeatures.enum_type f1, int f2)/+noexcept+/;+/ 591 592 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionToolBar::ToolBarFeatures) +/ 593 /+ #endif +/ // QT_CONFIG(toolbar) 594 595 /// Binding for C++ class [QStyleOptionProgressBar](https://doc.qt.io/qt-6/qstyleoptionprogressbar.html). 596 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionProgressBar 597 { 598 public QStyleOption base0; 599 alias base0 this; 600 alias OptionType = QStyleOption.OptionType; 601 public: 602 enum StyleOptionType { Type = OptionType.SO_ProgressBar } 603 enum StyleOptionVersion { Version = 1 } 604 605 int minimum; 606 int maximum; 607 int progress; 608 QString text; 609 /+ Qt:: +/qt.core.namespace.Alignment textAlignment; 610 bool textVisible; 611 bool invertedAppearance; 612 bool bottomToTop; 613 614 @disable this(); 615 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 616 ref typeof(this) rawConstructor(); 617 static typeof(this) create() 618 { 619 typeof(this) r = typeof(this).init; 620 r.rawConstructor(); 621 return r; 622 } 623 624 @disable this(this); 625 this(ref const(QStyleOptionProgressBar) other) 626 { 627 text = QString.create(); 628 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 629 this = other; 630 } 631 /+ QStyleOptionProgressBar &operator=(const QStyleOptionProgressBar &) = default; +/ 632 633 protected: 634 this(int version_); 635 mixin(CREATE_CONVENIENCE_WRAPPERS); 636 } 637 638 /// Binding for C++ class [QStyleOptionMenuItem](https://doc.qt.io/qt-6/qstyleoptionmenuitem.html). 639 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionMenuItem 640 { 641 public QStyleOption base0; 642 alias base0 this; 643 alias OptionType = QStyleOption.OptionType; 644 public: 645 enum StyleOptionType { Type = OptionType.SO_MenuItem } 646 enum StyleOptionVersion { Version = 1 } 647 648 enum MenuItemType { Normal, DefaultItem, Separator, SubMenu, Scroller, TearOff, Margin, 649 EmptyArea } 650 enum CheckType { NotCheckable, Exclusive, NonExclusive } 651 652 MenuItemType menuItemType; 653 CheckType checkType; 654 bool checked; 655 bool menuHasCheckableItems; 656 QRect menuRect; 657 QString text; 658 QIcon icon; 659 int maxIconWidth; 660 int reservedShortcutWidth; 661 QFont font; 662 663 @disable this(); 664 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 665 ref typeof(this) rawConstructor(); 666 static typeof(this) create() 667 { 668 typeof(this) r = typeof(this).init; 669 r.rawConstructor(); 670 return r; 671 } 672 673 @disable this(this); 674 this(ref const(QStyleOptionMenuItem) other) 675 { 676 text = QString.create; 677 font = QFont.create; 678 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 679 this = other; 680 } 681 /+ QStyleOptionMenuItem &operator=(const QStyleOptionMenuItem &) = default; +/ 682 683 protected: 684 this(int version_); 685 mixin(CREATE_CONVENIENCE_WRAPPERS); 686 } 687 688 /// Binding for C++ class [QStyleOptionDockWidget](https://doc.qt.io/qt-6/qstyleoptiondockwidget.html). 689 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionDockWidget 690 { 691 public QStyleOption base0; 692 alias base0 this; 693 alias OptionType = QStyleOption.OptionType; 694 public: 695 enum StyleOptionType { Type = OptionType.SO_DockWidget } 696 enum StyleOptionVersion { Version = 1 } 697 698 QString title; 699 bool closable; 700 bool movable; 701 bool floatable; 702 bool verticalTitleBar; 703 704 @disable this(); 705 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 706 ref typeof(this) rawConstructor(); 707 static typeof(this) create() 708 { 709 typeof(this) r = typeof(this).init; 710 r.rawConstructor(); 711 return r; 712 } 713 714 @disable this(this); 715 this(ref const(QStyleOptionDockWidget) other) 716 { 717 title = QString.create(); 718 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 719 this = other; 720 } 721 /+ QStyleOptionDockWidget &operator=(const QStyleOptionDockWidget &) = default; +/ 722 723 protected: 724 this(int version_); 725 mixin(CREATE_CONVENIENCE_WRAPPERS); 726 } 727 728 /+ #if QT_CONFIG(itemviews) +/ 729 730 /// Binding for C++ class [QStyleOptionViewItem](https://doc.qt.io/qt-6/qstyleoptionviewitem.html). 731 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionViewItem 732 { 733 public QStyleOption base0; 734 alias base0 this; 735 alias OptionType = QStyleOption.OptionType; 736 public: 737 enum StyleOptionType { Type = OptionType.SO_ViewItem } 738 enum StyleOptionVersion { Version = 1 } 739 740 enum Position { Left, Right, Top, Bottom } 741 742 /+ Qt:: +/qt.core.namespace.Alignment displayAlignment; 743 /+ Qt:: +/qt.core.namespace.Alignment decorationAlignment; 744 /+ Qt:: +/qt.core.namespace.TextElideMode textElideMode; 745 Position decorationPosition; 746 QSize decorationSize; 747 QFont font; 748 bool showDecorationSelected; 749 750 enum ViewItemFeature { 751 None = 0x00, 752 WrapText = 0x01, 753 Alternate = 0x02, 754 HasCheckIndicator = 0x04, 755 HasDisplay = 0x08, 756 HasDecoration = 0x10 757 } 758 /+ Q_DECLARE_FLAGS(ViewItemFeatures, ViewItemFeature) +/ 759 alias ViewItemFeatures = QFlags!(ViewItemFeature); 760 ViewItemFeatures features; 761 762 QLocale locale; 763 /*const*/ QWidget widget; 764 765 enum ViewItemPosition { Invalid, Beginning, Middle, End, OnlyOne } 766 767 QModelIndex index; 768 /+ Qt:: +/qt.core.namespace.CheckState checkState; 769 QIcon icon; 770 QString text; 771 ViewItemPosition viewItemPosition; 772 QBrush backgroundBrush; 773 774 @disable this(); 775 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 776 ref typeof(this) rawConstructor(); 777 static typeof(this) create() 778 { 779 typeof(this) r = typeof(this).init; 780 r.rawConstructor(); 781 return r; 782 } 783 784 @disable this(this); 785 this(ref const(QStyleOptionViewItem) other) 786 { 787 font = QFont.create; 788 text = QString.create; 789 locale = QLocale.create; 790 backgroundBrush = QBrush.create; 791 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 792 this = other; 793 } 794 /+ QStyleOptionViewItem &operator=(const QStyleOptionViewItem &) = default; +/ 795 796 protected: 797 this(int version_); 798 mixin(CREATE_CONVENIENCE_WRAPPERS); 799 } 800 /+pragma(inline, true) QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) operator |(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type)(f1)|f2;}+/ 801 /+pragma(inline, true) QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) operator |(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 802 /+pragma(inline, true) QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) operator &(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type)(f1)&f2;}+/ 803 /+pragma(inline, true) QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) operator &(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 804 /+pragma(inline, true) void operator +(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/;+/ 805 /+pragma(inline, true) void operator +(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/;+/ 806 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/;+/ 807 /+pragma(inline, true) void operator -(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/;+/ 808 /+pragma(inline, true) void operator -(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/;+/ 809 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionViewItem.ViewItemFeatures.enum_type) f2)/+noexcept+/;+/ 810 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 811 /+pragma(inline, true) void operator +(int f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/;+/ 812 /+pragma(inline, true) void operator +(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, int f2)/+noexcept+/;+/ 813 /+pragma(inline, true) void operator -(int f1, QStyleOptionViewItem.ViewItemFeatures.enum_type f2)/+noexcept+/;+/ 814 /+pragma(inline, true) void operator -(QStyleOptionViewItem.ViewItemFeatures.enum_type f1, int f2)/+noexcept+/;+/ 815 816 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionViewItem::ViewItemFeatures) +/ 817 /+ #endif +/ // QT_CONFIG(itemviews) 818 819 /// Binding for C++ class [QStyleOptionToolBox](https://doc.qt.io/qt-6/qstyleoptiontoolbox.html). 820 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionToolBox 821 { 822 public QStyleOption base0; 823 alias base0 this; 824 alias OptionType = QStyleOption.OptionType; 825 public: 826 enum StyleOptionType { Type = OptionType.SO_ToolBox } 827 enum StyleOptionVersion { Version = 1 } 828 829 QString text; 830 QIcon icon; 831 832 enum TabPosition { Beginning, Middle, End, OnlyOneTab } 833 enum SelectedPosition { NotAdjacent, NextIsSelected, PreviousIsSelected } 834 835 TabPosition position; 836 SelectedPosition selectedPosition; 837 838 @disable this(); 839 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 840 ref typeof(this) rawConstructor(); 841 static typeof(this) create() 842 { 843 typeof(this) r = typeof(this).init; 844 r.rawConstructor(); 845 return r; 846 } 847 848 @disable this(this); 849 this(ref const(QStyleOptionToolBox) other) 850 { 851 text = QString.create; 852 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 853 this = other; 854 } 855 /+ QStyleOptionToolBox &operator=(const QStyleOptionToolBox &) = default; +/ 856 857 protected: 858 this(int version_); 859 mixin(CREATE_CONVENIENCE_WRAPPERS); 860 } 861 862 /+ #if QT_CONFIG(rubberband) +/ 863 /// Binding for C++ class [QStyleOptionRubberBand](https://doc.qt.io/qt-6/qstyleoptionrubberband.html). 864 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionRubberBand 865 { 866 public QStyleOption base0; 867 alias base0 this; 868 alias OptionType = QStyleOption.OptionType; 869 public: 870 enum StyleOptionType { Type = OptionType.SO_RubberBand } 871 enum StyleOptionVersion { Version = 1 } 872 873 QRubberBand.Shape shape; 874 bool opaque; 875 876 @disable this(); 877 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 878 ref typeof(this) rawConstructor(); 879 static typeof(this) create() 880 { 881 typeof(this) r = typeof(this).init; 882 r.rawConstructor(); 883 return r; 884 } 885 886 @disable this(this); 887 this(ref const(QStyleOptionRubberBand) other) 888 { 889 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 890 this = other; 891 } 892 /+ QStyleOptionRubberBand &operator=(const QStyleOptionRubberBand &) = default; +/ 893 894 protected: 895 this(int version_); 896 mixin(CREATE_CONVENIENCE_WRAPPERS); 897 } 898 /+ #endif +/ // QT_CONFIG(rubberband) 899 900 // -------------------------- Complex style options ------------------------------- 901 /// Binding for C++ class [QStyleOptionComplex](https://doc.qt.io/qt-6/qstyleoptioncomplex.html). 902 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionComplex 903 { 904 public QStyleOption base0; 905 alias base0 this; 906 alias OptionType = QStyleOption.OptionType; 907 public: 908 enum StyleOptionType { Type = OptionType.SO_Complex } 909 enum StyleOptionVersion { Version = 1 } 910 911 QStyle.SubControls subControls; 912 QStyle.SubControls activeSubControls; 913 914 @disable this(); 915 this(int version_/+ = StyleOptionVersion.Version+/, int type = OptionType.SO_Complex); 916 @disable this(this); 917 this(ref const(QStyleOptionComplex) other) 918 { 919 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 920 this = other; 921 } 922 /+ QStyleOptionComplex &operator=(const QStyleOptionComplex &) = default; +/ 923 mixin(CREATE_CONVENIENCE_WRAPPERS); 924 } 925 926 /+ #if QT_CONFIG(slider) +/ 927 /// Binding for C++ class [QStyleOptionSlider](https://doc.qt.io/qt-6/qstyleoptionslider.html). 928 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionSlider 929 { 930 public QStyleOptionComplex base0; 931 alias base0 this; 932 alias OptionType = QStyleOption.OptionType; 933 public: 934 enum StyleOptionType { Type = OptionType.SO_Slider } 935 enum StyleOptionVersion { Version = 1 } 936 937 /+ Qt:: +/qt.core.namespace.Orientation orientation; 938 int minimum; 939 int maximum; 940 QSlider.TickPosition tickPosition; 941 int tickInterval; 942 bool upsideDown; 943 int sliderPosition; 944 int sliderValue; 945 int singleStep; 946 int pageStep; 947 qreal notchTarget; 948 bool dialWrapping; 949 /+ Qt:: +/qt.core.namespace.KeyboardModifiers keyboardModifiers; 950 951 @disable this(); 952 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 953 ref typeof(this) rawConstructor(); 954 static typeof(this) create() 955 { 956 typeof(this) r = typeof(this).init; 957 r.rawConstructor(); 958 return r; 959 } 960 961 @disable this(this); 962 this(ref const(QStyleOptionSlider) other) 963 { 964 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 965 this = other; 966 } 967 /+ QStyleOptionSlider &operator=(const QStyleOptionSlider &) = default; +/ 968 969 protected: 970 this(int version_); 971 mixin(CREATE_CONVENIENCE_WRAPPERS); 972 } 973 /+ #endif // QT_CONFIG(slider) 974 975 #if QT_CONFIG(spinbox) +/ 976 /// Binding for C++ class [QStyleOptionSpinBox](https://doc.qt.io/qt-6/qstyleoptionspinbox.html). 977 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionSpinBox 978 { 979 public QStyleOptionComplex base0; 980 alias base0 this; 981 alias OptionType = QStyleOption.OptionType; 982 public: 983 enum StyleOptionType { Type = OptionType.SO_SpinBox } 984 enum StyleOptionVersion { Version = 1 } 985 986 QAbstractSpinBox.ButtonSymbols buttonSymbols; 987 QAbstractSpinBox.StepEnabled stepEnabled; 988 bool frame; 989 990 @disable this(); 991 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 992 ref typeof(this) rawConstructor(); 993 static typeof(this) create() 994 { 995 typeof(this) r = typeof(this).init; 996 r.rawConstructor(); 997 return r; 998 } 999 1000 @disable this(this); 1001 this(ref const(QStyleOptionSpinBox) other) 1002 { 1003 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1004 this = other; 1005 } 1006 /+ QStyleOptionSpinBox &operator=(const QStyleOptionSpinBox &) = default; +/ 1007 1008 protected: 1009 this(int version_); 1010 mixin(CREATE_CONVENIENCE_WRAPPERS); 1011 } 1012 /+ #endif +/ // QT_CONFIG(spinbox) 1013 1014 /// Binding for C++ class [QStyleOptionToolButton](https://doc.qt.io/qt-6/qstyleoptiontoolbutton.html). 1015 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionToolButton 1016 { 1017 public QStyleOptionComplex base0; 1018 alias base0 this; 1019 alias OptionType = QStyleOption.OptionType; 1020 public: 1021 enum StyleOptionType { Type = OptionType.SO_ToolButton } 1022 enum StyleOptionVersion { Version = 1 } 1023 1024 enum ToolButtonFeature { None = 0x00, Arrow = 0x01, Menu = 0x04, MenuButtonPopup = ToolButtonFeature.Menu, PopupDelay = 0x08, 1025 HasMenu = 0x10 } 1026 /+ Q_DECLARE_FLAGS(ToolButtonFeatures, ToolButtonFeature) +/ 1027 alias ToolButtonFeatures = QFlags!(ToolButtonFeature); 1028 ToolButtonFeatures features; 1029 QIcon icon; 1030 QSize iconSize; 1031 QString text; 1032 /+ Qt:: +/qt.core.namespace.ArrowType arrowType; 1033 /+ Qt:: +/qt.core.namespace.ToolButtonStyle toolButtonStyle; 1034 QPoint pos; 1035 QFont font; 1036 1037 @disable this(); 1038 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1039 ref typeof(this) rawConstructor(); 1040 static typeof(this) create() 1041 { 1042 typeof(this) r = typeof(this).init; 1043 r.rawConstructor(); 1044 return r; 1045 } 1046 1047 @disable this(this); 1048 this(ref const(QStyleOptionToolButton) other) 1049 { 1050 text = QString.create; 1051 font = QFont.create; 1052 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1053 this = other; 1054 } 1055 /+ QStyleOptionToolButton &operator=(const QStyleOptionToolButton &) = default; +/ 1056 1057 protected: 1058 this(int version_); 1059 mixin(CREATE_CONVENIENCE_WRAPPERS); 1060 } 1061 /+pragma(inline, true) QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) operator |(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type)(f1)|f2;}+/ 1062 /+pragma(inline, true) QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) operator |(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/{return f2|f1;}+/ 1063 /+pragma(inline, true) QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) operator &(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/{return QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type)(f1)&f2;}+/ 1064 /+pragma(inline, true) QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) operator &(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/{return f2&f1;}+/ 1065 /+pragma(inline, true) void operator +(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/;+/ 1066 /+pragma(inline, true) void operator +(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/;+/ 1067 /+pragma(inline, true) void operator +(int f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/;+/ 1068 /+pragma(inline, true) void operator -(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/;+/ 1069 /+pragma(inline, true) void operator -(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/;+/ 1070 /+pragma(inline, true) void operator -(int f1, QFlags!(QStyleOptionToolButton.ToolButtonFeatures.enum_type) f2)/+noexcept+/;+/ 1071 /+pragma(inline, true) QIncompatibleFlag operator |(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, int f2)/+noexcept+/{return QIncompatibleFlag(int(f1)|f2);}+/ 1072 /+pragma(inline, true) void operator +(int f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/;+/ 1073 /+pragma(inline, true) void operator +(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, int f2)/+noexcept+/;+/ 1074 /+pragma(inline, true) void operator -(int f1, QStyleOptionToolButton.ToolButtonFeatures.enum_type f2)/+noexcept+/;+/ 1075 /+pragma(inline, true) void operator -(QStyleOptionToolButton.ToolButtonFeatures.enum_type f1, int f2)/+noexcept+/;+/ 1076 1077 /+ Q_DECLARE_OPERATORS_FOR_FLAGS(QStyleOptionToolButton::ToolButtonFeatures) +/ 1078 /// Binding for C++ class [QStyleOptionComboBox](https://doc.qt.io/qt-6/qstyleoptioncombobox.html). 1079 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionComboBox 1080 { 1081 public QStyleOptionComplex base0; 1082 alias base0 this; 1083 alias OptionType = QStyleOption.OptionType; 1084 public: 1085 enum StyleOptionType { Type = OptionType.SO_ComboBox } 1086 enum StyleOptionVersion { Version = 1 } 1087 1088 bool editable; 1089 QRect popupRect; 1090 bool frame; 1091 QString currentText; 1092 QIcon currentIcon; 1093 QSize iconSize; 1094 /+ Qt:: +/qt.core.namespace.Alignment textAlignment = /+ Qt:: +/qt.core.namespace.AlignmentFlag.AlignLeft | /+ Qt:: +/qt.core.namespace.AlignmentFlag.AlignVCenter; 1095 1096 @disable this(); 1097 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1098 ref typeof(this) rawConstructor(); 1099 static typeof(this) create() 1100 { 1101 typeof(this) r = typeof(this).init; 1102 r.rawConstructor(); 1103 return r; 1104 } 1105 1106 @disable this(this); 1107 this(ref const(QStyleOptionComboBox) other) 1108 { 1109 currentText = QString.create; 1110 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1111 this = other; 1112 } 1113 /+ QStyleOptionComboBox &operator=(const QStyleOptionComboBox &) = default; +/ 1114 1115 protected: 1116 this(int version_); 1117 mixin(CREATE_CONVENIENCE_WRAPPERS); 1118 } 1119 1120 /// Binding for C++ class [QStyleOptionTitleBar](https://doc.qt.io/qt-6/qstyleoptiontitlebar.html). 1121 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionTitleBar 1122 { 1123 public QStyleOptionComplex base0; 1124 alias base0 this; 1125 alias OptionType = QStyleOption.OptionType; 1126 public: 1127 enum StyleOptionType { Type = OptionType.SO_TitleBar } 1128 enum StyleOptionVersion { Version = 1 } 1129 1130 QString text; 1131 QIcon icon; 1132 int titleBarState; 1133 /+ Qt:: +/qt.core.namespace.WindowFlags titleBarFlags; 1134 1135 @disable this(); 1136 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1137 ref typeof(this) rawConstructor(); 1138 static typeof(this) create() 1139 { 1140 typeof(this) r = typeof(this).init; 1141 r.rawConstructor(); 1142 return r; 1143 } 1144 1145 @disable this(this); 1146 this(ref const(QStyleOptionTitleBar) other) 1147 { 1148 text = QString.create; 1149 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1150 this = other; 1151 } 1152 /+ QStyleOptionTitleBar &operator=(const QStyleOptionTitleBar &) = default; +/ 1153 1154 protected: 1155 this(int version_); 1156 mixin(CREATE_CONVENIENCE_WRAPPERS); 1157 } 1158 1159 /// Binding for C++ class [QStyleOptionGroupBox](https://doc.qt.io/qt-6/qstyleoptiongroupbox.html). 1160 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionGroupBox 1161 { 1162 public QStyleOptionComplex base0; 1163 alias base0 this; 1164 alias OptionType = QStyleOption.OptionType; 1165 public: 1166 enum StyleOptionType { Type = OptionType.SO_GroupBox } 1167 enum StyleOptionVersion { Version = 1 } 1168 1169 QStyleOptionFrame.FrameFeatures features; 1170 QString text; 1171 /+ Qt:: +/qt.core.namespace.Alignment textAlignment; 1172 QColor textColor; 1173 int lineWidth; 1174 int midLineWidth; 1175 1176 @disable this(); 1177 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1178 ref typeof(this) rawConstructor(); 1179 static typeof(this) create() 1180 { 1181 typeof(this) r = typeof(this).init; 1182 r.rawConstructor(); 1183 return r; 1184 } 1185 1186 @disable this(this); 1187 this(ref const(QStyleOptionGroupBox) other) 1188 { 1189 text = QString.create; 1190 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1191 this = other; 1192 } 1193 /+ QStyleOptionGroupBox &operator=(const QStyleOptionGroupBox &) = default; +/ 1194 protected: 1195 this(int version_); 1196 mixin(CREATE_CONVENIENCE_WRAPPERS); 1197 } 1198 1199 /// Binding for C++ class [QStyleOptionSizeGrip](https://doc.qt.io/qt-6/qstyleoptionsizegrip.html). 1200 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionSizeGrip 1201 { 1202 public QStyleOptionComplex base0; 1203 alias base0 this; 1204 alias OptionType = QStyleOption.OptionType; 1205 public: 1206 enum StyleOptionType { Type = OptionType.SO_SizeGrip } 1207 enum StyleOptionVersion { Version = 1 } 1208 1209 /+ Qt:: +/qt.core.namespace.Corner corner; 1210 1211 @disable this(); 1212 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1213 ref typeof(this) rawConstructor(); 1214 static typeof(this) create() 1215 { 1216 typeof(this) r = typeof(this).init; 1217 r.rawConstructor(); 1218 return r; 1219 } 1220 1221 @disable this(this); 1222 this(ref const(QStyleOptionSizeGrip) other) 1223 { 1224 this.base0 = QStyleOptionComplex(StyleOptionVersion.Version, StyleOptionType.Type); 1225 this = other; 1226 } 1227 /+ QStyleOptionSizeGrip &operator=(const QStyleOptionSizeGrip &) = default; +/ 1228 protected: 1229 this(int version_); 1230 mixin(CREATE_CONVENIENCE_WRAPPERS); 1231 } 1232 1233 /// Binding for C++ class [QStyleOptionGraphicsItem](https://doc.qt.io/qt-6/qstyleoptiongraphicsitem.html). 1234 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleOptionGraphicsItem 1235 { 1236 public QStyleOption base0; 1237 alias base0 this; 1238 alias OptionType = QStyleOption.OptionType; 1239 public: 1240 enum StyleOptionType { Type = OptionType.SO_GraphicsItem } 1241 enum StyleOptionVersion { Version = 1 } 1242 1243 QRectF exposedRect; 1244 1245 @disable this(); 1246 pragma(mangle, defaultConstructorMangling(__traits(identifier, typeof(this)))) 1247 ref typeof(this) rawConstructor(); 1248 static typeof(this) create() 1249 { 1250 typeof(this) r = typeof(this).init; 1251 r.rawConstructor(); 1252 return r; 1253 } 1254 1255 @disable this(this); 1256 this(ref const(QStyleOptionGraphicsItem) other) 1257 { 1258 this.base0 = QStyleOption(StyleOptionVersion.Version, StyleOptionType.Type); 1259 this = other; 1260 } 1261 /+ QStyleOptionGraphicsItem &operator=(const QStyleOptionGraphicsItem &) = default; +/ 1262 static qreal levelOfDetailFromTransform(ref const(QTransform) worldTransform); 1263 protected: 1264 this(int version_); 1265 mixin(CREATE_CONVENIENCE_WRAPPERS); 1266 } 1267 1268 T qstyleoption_cast(T)(const(QStyleOption)* opt) 1269 { 1270 alias Opt = /+ std:: +/remove_cv!(/+ std:: +/remove_pointer!(T).__remove_pointer_helper.type).type; 1271 if (opt && opt.version_ >= Opt.Version && (opt.type == Opt.Type 1272 || int(Opt.Type) == QStyleOption.OptionType.SO_Default 1273 || (int(Opt.Type) == QStyleOption.OptionType.SO_Complex 1274 && opt.type > QStyleOption.OptionType.SO_Complex))) 1275 return static_cast!(T)(opt); 1276 return null; 1277 } 1278 1279 T qstyleoption_cast(T)(QStyleOption* opt) 1280 { 1281 alias Opt = /+ std:: +/remove_cv!(/+ std:: +/remove_pointer!(T).__remove_pointer_helper.type).type; 1282 if (opt && opt.version_ >= Opt.Version && (opt.type == Opt.Type 1283 || int(Opt.Type) == QStyleOption.OptionType.SO_Default 1284 || (int(Opt.Type) == QStyleOption.OptionType.SO_Complex 1285 && opt.type > QStyleOption.OptionType.SO_Complex))) 1286 return static_cast!(T)(opt); 1287 return null; 1288 } 1289 1290 // -------------------------- QStyleHintReturn ------------------------------- 1291 /// Binding for C++ class [QStyleHintReturn](https://doc.qt.io/qt-6/qstylehintreturn.html). 1292 extern(C++, class) struct /+ Q_WIDGETS_EXPORT +/ QStyleHintReturn { 1293 public: 1294 enum HintReturnType { 1295 SH_Default=0xf000, SH_Mask, SH_Variant 1296 } 1297 1298 enum StyleOptionType { Type = HintReturnType.SH_Default } 1299 enum StyleOptionVersion { Version = 1 } 1300 1301 @disable this(); 1302 this(int version_/+ = QStyleOption.StyleOptionVersion.Version+/, int type = HintReturnType.SH_Default); 1303 ~this(); 1304 1305 int version_; 1306 int type; 1307 mixin(CREATE_CONVENIENCE_WRAPPERS); 1308 } 1309 1310 /+ 1311 /// Binding for C++ class [QStyleHintReturnMask](https://doc.qt.io/qt-6/qstylehintreturnmask.html). 1312 class /+ Q_WIDGETS_EXPORT +/ QStyleHintReturnMask : QStyleHintReturn { 1313 public: 1314 enum StyleOptionType { Type = HintReturnType.SH_Mask } 1315 enum StyleOptionVersion { Version = 1 } 1316 1317 this(); 1318 ~this(); 1319 1320 QRegion region; 1321 mixin(CREATE_CONVENIENCE_WRAPPERS); 1322 } 1323 1324 /// Binding for C++ class [QStyleHintReturnVariant](https://doc.qt.io/qt-6/qstylehintreturnvariant.html). 1325 class /+ Q_WIDGETS_EXPORT +/ QStyleHintReturnVariant : QStyleHintReturn { 1326 public: 1327 enum StyleOptionType { Type = HintReturnType.SH_Variant } 1328 enum StyleOptionVersion { Version = 1 } 1329 1330 this(); 1331 ~this(); 1332 1333 QVariant variant; 1334 mixin(CREATE_CONVENIENCE_WRAPPERS); 1335 } 1336 +/ 1337 1338 T qstyleoption_cast(T)(const(QStyleHintReturn)* hint) 1339 { 1340 alias Opt = /+ std:: +/remove_cv!(/+ std:: +/remove_pointer!(T).__remove_pointer_helper.type).type; 1341 if (hint && hint.version_ <= Opt.Version && 1342 (hint.type == Opt.Type || int(Opt.Type) == QStyleHintReturn.HintReturnType.SH_Default)) 1343 return static_cast!(T)(hint); 1344 return null; 1345 } 1346 1347 T qstyleoption_cast(T)(QStyleHintReturn* hint) 1348 { 1349 alias Opt = /+ std:: +/remove_cv!(/+ std:: +/remove_pointer!(T).__remove_pointer_helper.type).type; 1350 if (hint && hint.version_ <= Opt.Version && 1351 (hint.type == Opt.Type || int(Opt.Type) == QStyleHintReturn.HintReturnType.SH_Default)) 1352 return static_cast!(T)(hint); 1353 return null; 1354 } 1355 1356 /+ #if !defined(QT_NO_DEBUG_STREAM) 1357 Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, const QStyleOption::OptionType &optionType); 1358 Q_WIDGETS_EXPORT QDebug operator<<(QDebug debug, const QStyleOption &option); 1359 #endif +/ 1360