io.qt.core.Qt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation
Show all versions of qtjambi Show documentation
QtJambi base module containing QtCore, QtGui and QtWidgets.
package io.qt.core;
import io.qt.*;
/**
* Contains miscellaneous identifiers used throughout the Qt library
* Java wrapper for Qt header file Qt
*/
public final class Qt
{
static {
QtJambi_LibraryUtilities.initialize();
}
private Qt() throws java.lang.InstantiationError { throw new java.lang.InstantiationError("Cannot instantiate namespace Qt."); }
/**
* Java wrapper for Qt enum Qt::AlignmentFlag
*
* @see Alignment
*/
@QtRejectedEntries({"AlignLeading", "AlignTrailing"})
public enum AlignmentFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
AlignLeft(1),
/**
* Representing Qt::
*/
AlignLeading(1),
/**
* Representing Qt::
*/
AlignRight(2),
/**
* Representing Qt::
*/
AlignTrailing(2),
/**
* Representing Qt::
*/
AlignHCenter(4),
/**
* Representing Qt::
*/
AlignJustify(8),
/**
* Representing Qt::
*/
AlignAbsolute(16),
/**
* Representing Qt::
*/
AlignHorizontal_Mask(31),
/**
* Representing Qt::
*/
AlignTop(32),
/**
* Representing Qt::
*/
AlignBottom(64),
/**
* Representing Qt::
*/
AlignVCenter(128),
/**
* Representing Qt::
*/
AlignBaseline(256),
/**
* Representing Qt::
*/
AlignVertical_Mask(480),
/**
* Representing Qt::
*/
AlignCenter(132);
static {
QtJambi_LibraryUtilities.initialize();
}
private AlignmentFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull Alignment asFlags() {
return new Alignment(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Alignment combined(@NonNull AlignmentFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Alignment cleared(@NonNull AlignmentFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link Alignment} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull Alignment flags(@Nullable AlignmentFlag @NonNull... values) {
return new Alignment(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull AlignmentFlag resolve(int value) {
switch (value) {
case 1: return AlignLeft;
case 2: return AlignRight;
case 4: return AlignHCenter;
case 8: return AlignJustify;
case 16: return AlignAbsolute;
case 31: return AlignHorizontal_Mask;
case 32: return AlignTop;
case 64: return AlignBottom;
case 128: return AlignVCenter;
case 256: return AlignBaseline;
case 480: return AlignVertical_Mask;
case 132: return AlignCenter;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link AlignmentFlag}
*/
public static final class Alignment extends QFlags implements Comparable {
private static final long serialVersionUID = 0xb582c1bff5b386cdL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new Alignment where the flags in args are set.
* @param args enum entries
*/
public Alignment(@Nullable AlignmentFlag @NonNull... args){
super(args);
}
/**
* Creates a new Alignment with given value.
* @param value
*/
public Alignment(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new Alignment
*/
@Override
public final @NonNull Alignment combined(@StrictNonNull AlignmentFlag e){
return new Alignment(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull Alignment setFlag(@Nullable AlignmentFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull Alignment setFlag(@Nullable AlignmentFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this Alignment.
* @return array of enum entries
*/
@Override
public final @NonNull AlignmentFlag @NonNull[] flags(){
return super.flags(AlignmentFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull Alignment clone(){
return new Alignment(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull Alignment other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::AnchorPoint
*/
@QtUnlistedEnum
public enum AnchorPoint implements QtEnumerator {
/**
* Representing Qt::
*/
AnchorLeft(0),
/**
* Representing Qt::
*/
AnchorHorizontalCenter(1),
/**
* Representing Qt::
*/
AnchorRight(2),
/**
* Representing Qt::
*/
AnchorTop(3),
/**
* Representing Qt::
*/
AnchorVerticalCenter(4),
/**
* Representing Qt::
*/
AnchorBottom(5);
static {
QtJambi_LibraryUtilities.initialize();
}
private AnchorPoint(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull AnchorPoint resolve(int value) {
switch (value) {
case 0: return AnchorLeft;
case 1: return AnchorHorizontalCenter;
case 2: return AnchorRight;
case 3: return AnchorTop;
case 4: return AnchorVerticalCenter;
case 5: return AnchorBottom;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ApplicationAttribute
*/
public enum ApplicationAttribute implements QtEnumerator {
/**
* Representing Qt::
*/
AA_QtQuickUseDefaultSizePolicy(1),
/**
* Representing Qt::
*/
AA_DontShowIconsInMenus(2),
/**
* Representing Qt::
*/
AA_NativeWindows(3),
/**
* Representing Qt::
*/
AA_DontCreateNativeWidgetSiblings(4),
/**
* Representing Qt::
*/
AA_PluginApplication(5),
/**
* Representing Qt::
*/
AA_DontUseNativeMenuBar(6),
/**
* Representing Qt::
*/
AA_MacDontSwapCtrlAndMeta(7),
/**
* Representing Qt::
*/
AA_Use96Dpi(8),
/**
* Representing Qt::
*/
AA_DisableNativeVirtualKeyboard(9),
/**
* Representing Qt::
*/
AA_SynthesizeTouchForUnhandledMouseEvents(11),
/**
* Representing Qt::
*/
AA_SynthesizeMouseForUnhandledTouchEvents(12),
@Deprecated
/**
* Representing Qt::
* @deprecated High-DPI pixmaps are always enabled. This attribute no longer has any effect.
*/
AA_UseHighDpiPixmaps(13),
/**
* Representing Qt::
*/
AA_ForceRasterWidgets(14),
/**
* Representing Qt::
*/
AA_UseDesktopOpenGL(15),
/**
* Representing Qt::
*/
AA_UseOpenGLES(16),
/**
* Representing Qt::
*/
AA_UseSoftwareOpenGL(17),
/**
* Representing Qt::
*/
AA_ShareOpenGLContexts(18),
/**
* Representing Qt::
*/
AA_SetPalette(19),
@Deprecated
/**
* Representing Qt::
* @deprecated High-DPI scaling is always enabled. This attribute no longer has any effect.
*/
AA_EnableHighDpiScaling(20),
@Deprecated
/**
* Representing Qt::
* @deprecated High-DPI scaling is always enabled. This attribute no longer has any effect.
*/
AA_DisableHighDpiScaling(21),
/**
* Representing Qt::
*/
AA_UseStyleSheetPropagationInWidgetStyles(22),
/**
* Representing Qt::
*/
AA_DontUseNativeDialogs(23),
/**
* Representing Qt::
*/
AA_SynthesizeMouseForUnhandledTabletEvents(24),
/**
* Representing Qt::
*/
AA_CompressHighFrequencyEvents(25),
/**
* Representing Qt::
*/
AA_DontCheckOpenGLContextThreadAffinity(26),
/**
* Representing Qt::
*/
AA_DisableShaderDiskCache(27),
/**
* Representing Qt::
*/
AA_DontShowShortcutsInContextMenus(28),
/**
* Representing Qt::
*/
AA_CompressTabletEvents(29),
/**
* Representing Qt::
*/
AA_DisableSessionManager(31),
/**
* Representing Qt::
*/
AA_AttributeCount(32);
static {
QtJambi_LibraryUtilities.initialize();
}
private ApplicationAttribute(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ApplicationAttribute resolve(int value) {
switch (value) {
case 1: return AA_QtQuickUseDefaultSizePolicy;
case 2: return AA_DontShowIconsInMenus;
case 3: return AA_NativeWindows;
case 4: return AA_DontCreateNativeWidgetSiblings;
case 5: return AA_PluginApplication;
case 6: return AA_DontUseNativeMenuBar;
case 7: return AA_MacDontSwapCtrlAndMeta;
case 8: return AA_Use96Dpi;
case 9: return AA_DisableNativeVirtualKeyboard;
case 11: return AA_SynthesizeTouchForUnhandledMouseEvents;
case 12: return AA_SynthesizeMouseForUnhandledTouchEvents;
case 13: return AA_UseHighDpiPixmaps;
case 14: return AA_ForceRasterWidgets;
case 15: return AA_UseDesktopOpenGL;
case 16: return AA_UseOpenGLES;
case 17: return AA_UseSoftwareOpenGL;
case 18: return AA_ShareOpenGLContexts;
case 19: return AA_SetPalette;
case 20: return AA_EnableHighDpiScaling;
case 21: return AA_DisableHighDpiScaling;
case 22: return AA_UseStyleSheetPropagationInWidgetStyles;
case 23: return AA_DontUseNativeDialogs;
case 24: return AA_SynthesizeMouseForUnhandledTabletEvents;
case 25: return AA_CompressHighFrequencyEvents;
case 26: return AA_DontCheckOpenGLContextThreadAffinity;
case 27: return AA_DisableShaderDiskCache;
case 28: return AA_DontShowShortcutsInContextMenus;
case 29: return AA_CompressTabletEvents;
case 31: return AA_DisableSessionManager;
case 32: return AA_AttributeCount;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ApplicationState
*
* @see ApplicationStates
*/
public enum ApplicationState implements QtFlagEnumerator {
/**
* Representing Qt::
*/
ApplicationSuspended(0),
/**
* Representing Qt::
*/
ApplicationHidden(1),
/**
* Representing Qt::
*/
ApplicationInactive(2),
/**
* Representing Qt::
*/
ApplicationActive(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ApplicationState(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull ApplicationStates asFlags() {
return new ApplicationStates(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ApplicationStates combined(@NonNull ApplicationState e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ApplicationStates cleared(@NonNull ApplicationState e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link ApplicationStates} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull ApplicationStates flags(@Nullable ApplicationState @NonNull... values) {
return new ApplicationStates(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ApplicationState resolve(int value) {
switch (value) {
case 0: return ApplicationSuspended;
case 1: return ApplicationHidden;
case 2: return ApplicationInactive;
case 4: return ApplicationActive;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link ApplicationState}
*/
public static final class ApplicationStates extends QFlags implements Comparable {
private static final long serialVersionUID = 0xe687331abc8d9d6eL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new ApplicationStates where the flags in args are set.
* @param args enum entries
*/
public ApplicationStates(@Nullable ApplicationState @NonNull... args){
super(args);
}
/**
* Creates a new ApplicationStates with given value.
* @param value
*/
public ApplicationStates(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new ApplicationStates
*/
@Override
public final @NonNull ApplicationStates combined(@StrictNonNull ApplicationState e){
return new ApplicationStates(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull ApplicationStates setFlag(@Nullable ApplicationState e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull ApplicationStates setFlag(@Nullable ApplicationState e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this ApplicationStates.
* @return array of enum entries
*/
@Override
public final @NonNull ApplicationState @NonNull[] flags(){
return super.flags(ApplicationState.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull ApplicationStates clone(){
return new ApplicationStates(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull ApplicationStates other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::ArrowType
*/
public enum ArrowType implements QtEnumerator {
/**
* Representing Qt::
*/
NoArrow(0),
/**
* Representing Qt::
*/
UpArrow(1),
/**
* Representing Qt::
*/
DownArrow(2),
/**
* Representing Qt::
*/
LeftArrow(3),
/**
* Representing Qt::
*/
RightArrow(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ArrowType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ArrowType resolve(int value) {
switch (value) {
case 0: return NoArrow;
case 1: return UpArrow;
case 2: return DownArrow;
case 3: return LeftArrow;
case 4: return RightArrow;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::AspectRatioMode
*/
public enum AspectRatioMode implements QtEnumerator {
/**
* Representing Qt::
*/
IgnoreAspectRatio(0),
/**
* Representing Qt::
*/
KeepAspectRatio(1),
/**
* Representing Qt::
*/
KeepAspectRatioByExpanding(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private AspectRatioMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull AspectRatioMode resolve(int value) {
switch (value) {
case 0: return IgnoreAspectRatio;
case 1: return KeepAspectRatio;
case 2: return KeepAspectRatioByExpanding;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::Axis
*/
public enum Axis implements QtEnumerator {
/**
* Representing Qt::
*/
XAxis(0),
/**
* Representing Qt::
*/
YAxis(1),
/**
* Representing Qt::
*/
ZAxis(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private Axis(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull Axis resolve(int value) {
switch (value) {
case 0: return XAxis;
case 1: return YAxis;
case 2: return ZAxis;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::BGMode
*/
public enum BGMode implements QtEnumerator {
/**
* Representing Qt::
*/
TransparentMode(0),
/**
* Representing Qt::
*/
OpaqueMode(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private BGMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull BGMode resolve(int value) {
switch (value) {
case 0: return TransparentMode;
case 1: return OpaqueMode;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::BrushStyle
*/
public enum BrushStyle implements QtEnumerator {
/**
* Representing Qt::
*/
NoBrush(0),
/**
* Representing Qt::
*/
SolidPattern(1),
/**
* Representing Qt::
*/
Dense1Pattern(2),
/**
* Representing Qt::
*/
Dense2Pattern(3),
/**
* Representing Qt::
*/
Dense3Pattern(4),
/**
* Representing Qt::
*/
Dense4Pattern(5),
/**
* Representing Qt::
*/
Dense5Pattern(6),
/**
* Representing Qt::
*/
Dense6Pattern(7),
/**
* Representing Qt::
*/
Dense7Pattern(8),
/**
* Representing Qt::
*/
HorPattern(9),
/**
* Representing Qt::
*/
VerPattern(10),
/**
* Representing Qt::
*/
CrossPattern(11),
/**
* Representing Qt::
*/
BDiagPattern(12),
/**
* Representing Qt::
*/
FDiagPattern(13),
/**
* Representing Qt::
*/
DiagCrossPattern(14),
/**
* Representing Qt::
*/
LinearGradientPattern(15),
/**
* Representing Qt::
*/
RadialGradientPattern(16),
/**
* Representing Qt::
*/
ConicalGradientPattern(17),
/**
* Representing Qt::
*/
TexturePattern(24);
static {
QtJambi_LibraryUtilities.initialize();
}
private BrushStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull BrushStyle resolve(int value) {
switch (value) {
case 0: return NoBrush;
case 1: return SolidPattern;
case 2: return Dense1Pattern;
case 3: return Dense2Pattern;
case 4: return Dense3Pattern;
case 5: return Dense4Pattern;
case 6: return Dense5Pattern;
case 7: return Dense6Pattern;
case 8: return Dense7Pattern;
case 9: return HorPattern;
case 10: return VerPattern;
case 11: return CrossPattern;
case 12: return BDiagPattern;
case 13: return FDiagPattern;
case 14: return DiagCrossPattern;
case 15: return LinearGradientPattern;
case 16: return RadialGradientPattern;
case 17: return ConicalGradientPattern;
case 24: return TexturePattern;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::CaseSensitivity
*/
public enum CaseSensitivity implements QtEnumerator {
/**
* Representing Qt::
*/
CaseInsensitive(0),
/**
* Representing Qt::
*/
CaseSensitive(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private CaseSensitivity(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull CaseSensitivity resolve(int value) {
switch (value) {
case 0: return CaseInsensitive;
case 1: return CaseSensitive;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::CheckState
*/
public enum CheckState implements QtEnumerator {
/**
* Representing Qt::
*/
Unchecked(0),
/**
* Representing Qt::
*/
PartiallyChecked(1),
/**
* Representing Qt::
*/
Checked(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private CheckState(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull CheckState resolve(int value) {
switch (value) {
case 0: return Unchecked;
case 1: return PartiallyChecked;
case 2: return Checked;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ChecksumType
*/
public enum ChecksumType implements QtEnumerator {
/**
* Representing Qt::
*/
ChecksumIso3309(0),
/**
* Representing Qt::
*/
ChecksumItuV41(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private ChecksumType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ChecksumType resolve(int value) {
switch (value) {
case 0: return ChecksumIso3309;
case 1: return ChecksumItuV41;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ClipOperation
*/
public enum ClipOperation implements QtEnumerator {
/**
* Representing Qt::
*/
NoClip(0),
/**
* Representing Qt::
*/
ReplaceClip(1),
/**
* Representing Qt::
*/
IntersectClip(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private ClipOperation(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ClipOperation resolve(int value) {
switch (value) {
case 0: return NoClip;
case 1: return ReplaceClip;
case 2: return IntersectClip;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ColorScheme
*/
public enum ColorScheme implements QtEnumerator {
/**
* Representing Qt::
*/
Unknown(0),
/**
* Representing Qt::
*/
Light(1),
/**
* Representing Qt::
*/
Dark(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private ColorScheme(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ColorScheme resolve(int value) {
switch (value) {
case 0: return Unknown;
case 1: return Light;
case 2: return Dark;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ConnectionType
*/
public enum ConnectionType implements QtEnumerator {
/**
* Representing Qt::
*/
AutoConnection(0),
/**
* Representing Qt::
*/
DirectConnection(1),
/**
* Representing Qt::
*/
QueuedConnection(2),
/**
* Representing Qt::
*/
BlockingQueuedConnection(3),
/**
* Representing Qt::
*/
UniqueConnection(128),
/**
* Representing Qt::
*/
SingleShotConnection(256);
static {
QtJambi_LibraryUtilities.initialize();
}
private ConnectionType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ConnectionType resolve(int value) {
switch (value) {
case 0: return AutoConnection;
case 1: return DirectConnection;
case 2: return QueuedConnection;
case 3: return BlockingQueuedConnection;
case 128: return UniqueConnection;
case 256: return SingleShotConnection;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ContextMenuPolicy
*/
public enum ContextMenuPolicy implements QtEnumerator {
/**
* Representing Qt::
*/
NoContextMenu(0),
/**
* Representing Qt::
*/
DefaultContextMenu(1),
/**
* Representing Qt::
*/
ActionsContextMenu(2),
/**
* Representing Qt::
*/
CustomContextMenu(3),
/**
* Representing Qt::
*/
PreventContextMenu(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ContextMenuPolicy(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ContextMenuPolicy resolve(int value) {
switch (value) {
case 0: return NoContextMenu;
case 1: return DefaultContextMenu;
case 2: return ActionsContextMenu;
case 3: return CustomContextMenu;
case 4: return PreventContextMenu;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::CoordinateSystem
*/
@QtUnlistedEnum
public enum CoordinateSystem implements QtEnumerator {
/**
* Representing Qt::
*/
DeviceCoordinates(0),
/**
* Representing Qt::
*/
LogicalCoordinates(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private CoordinateSystem(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull CoordinateSystem resolve(int value) {
switch (value) {
case 0: return DeviceCoordinates;
case 1: return LogicalCoordinates;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::Corner
*/
public enum Corner implements QtEnumerator {
/**
* Representing Qt::
*/
TopLeftCorner(0),
/**
* Representing Qt::
*/
TopRightCorner(1),
/**
* Representing Qt::
*/
BottomLeftCorner(2),
/**
* Representing Qt::
*/
BottomRightCorner(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private Corner(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull Corner resolve(int value) {
switch (value) {
case 0: return TopLeftCorner;
case 1: return TopRightCorner;
case 2: return BottomLeftCorner;
case 3: return BottomRightCorner;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::CursorMoveStyle
*/
public enum CursorMoveStyle implements QtEnumerator {
/**
* Representing Qt::
*/
LogicalMoveStyle(0),
/**
* Representing Qt::
*/
VisualMoveStyle(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private CursorMoveStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull CursorMoveStyle resolve(int value) {
switch (value) {
case 0: return LogicalMoveStyle;
case 1: return VisualMoveStyle;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::CursorShape
*/
@QtRejectedEntries({"LastCursor"})
public enum CursorShape implements QtEnumerator {
/**
* Representing Qt::
*/
ArrowCursor(0),
/**
* Representing Qt::
*/
UpArrowCursor(1),
/**
* Representing Qt::
*/
CrossCursor(2),
/**
* Representing Qt::
*/
WaitCursor(3),
/**
* Representing Qt::
*/
IBeamCursor(4),
/**
* Representing Qt::
*/
SizeVerCursor(5),
/**
* Representing Qt::
*/
SizeHorCursor(6),
/**
* Representing Qt::
*/
SizeBDiagCursor(7),
/**
* Representing Qt::
*/
SizeFDiagCursor(8),
/**
* Representing Qt::
*/
SizeAllCursor(9),
/**
* Representing Qt::
*/
BlankCursor(10),
/**
* Representing Qt::
*/
SplitVCursor(11),
/**
* Representing Qt::
*/
SplitHCursor(12),
/**
* Representing Qt::
*/
PointingHandCursor(13),
/**
* Representing Qt::
*/
ForbiddenCursor(14),
/**
* Representing Qt::
*/
WhatsThisCursor(15),
/**
* Representing Qt::
*/
BusyCursor(16),
/**
* Representing Qt::
*/
OpenHandCursor(17),
/**
* Representing Qt::
*/
ClosedHandCursor(18),
/**
* Representing Qt::
*/
DragCopyCursor(19),
/**
* Representing Qt::
*/
DragMoveCursor(20),
/**
* Representing Qt::
*/
DragLinkCursor(21),
/**
* Representing Qt::
*/
LastCursor(21),
/**
* Representing Qt::
*/
BitmapCursor(24),
/**
* Representing Qt::
*/
CustomCursor(25);
static {
QtJambi_LibraryUtilities.initialize();
}
private CursorShape(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull CursorShape resolve(int value) {
switch (value) {
case 0: return ArrowCursor;
case 1: return UpArrowCursor;
case 2: return CrossCursor;
case 3: return WaitCursor;
case 4: return IBeamCursor;
case 5: return SizeVerCursor;
case 6: return SizeHorCursor;
case 7: return SizeBDiagCursor;
case 8: return SizeFDiagCursor;
case 9: return SizeAllCursor;
case 10: return BlankCursor;
case 11: return SplitVCursor;
case 12: return SplitHCursor;
case 13: return PointingHandCursor;
case 14: return ForbiddenCursor;
case 15: return WhatsThisCursor;
case 16: return BusyCursor;
case 17: return OpenHandCursor;
case 18: return ClosedHandCursor;
case 19: return DragCopyCursor;
case 20: return DragMoveCursor;
case 21: return DragLinkCursor;
case 24: return BitmapCursor;
case 25: return CustomCursor;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::DateFormat
*/
public enum DateFormat implements QtEnumerator {
/**
* Representing Qt::
*/
TextDate(0),
/**
* Representing Qt::
*/
ISODate(1),
/**
* Representing Qt::
*/
RFC2822Date(8),
/**
* Representing Qt::
*/
ISODateWithMs(9);
static {
QtJambi_LibraryUtilities.initialize();
}
private DateFormat(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull DateFormat resolve(int value) {
switch (value) {
case 0: return TextDate;
case 1: return ISODate;
case 8: return RFC2822Date;
case 9: return ISODateWithMs;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::DayOfWeek
*/
public enum DayOfWeek implements QtEnumerator {
/**
* Representing Qt::
*/
Monday(1),
/**
* Representing Qt::
*/
Tuesday(2),
/**
* Representing Qt::
*/
Wednesday(3),
/**
* Representing Qt::
*/
Thursday(4),
/**
* Representing Qt::
*/
Friday(5),
/**
* Representing Qt::
*/
Saturday(6),
/**
* Representing Qt::
*/
Sunday(7);
static {
QtJambi_LibraryUtilities.initialize();
}
private DayOfWeek(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull DayOfWeek resolve(int value) {
switch (value) {
case 1: return Monday;
case 2: return Tuesday;
case 3: return Wednesday;
case 4: return Thursday;
case 5: return Friday;
case 6: return Saturday;
case 7: return Sunday;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::DockWidgetArea
*
* @see DockWidgetAreas
*/
@QtRejectedEntries({"AllDockWidgetAreas"})
public enum DockWidgetArea implements QtFlagEnumerator {
/**
* Representing Qt::
*/
LeftDockWidgetArea(1),
/**
* Representing Qt::
*/
RightDockWidgetArea(2),
/**
* Representing Qt::
*/
TopDockWidgetArea(4),
/**
* Representing Qt::
*/
BottomDockWidgetArea(8),
/**
* Representing Qt::
*/
DockWidgetArea_Mask(15),
/**
* Representing Qt::
*/
AllDockWidgetAreas(15),
/**
* Representing Qt::
*/
NoDockWidgetArea(0);
static {
QtJambi_LibraryUtilities.initialize();
}
private DockWidgetArea(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull DockWidgetAreas asFlags() {
return new DockWidgetAreas(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull DockWidgetAreas combined(@NonNull DockWidgetArea e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull DockWidgetAreas cleared(@NonNull DockWidgetArea e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link DockWidgetAreas} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull DockWidgetAreas flags(@Nullable DockWidgetArea @NonNull... values) {
return new DockWidgetAreas(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull DockWidgetArea resolve(int value) {
switch (value) {
case 1: return LeftDockWidgetArea;
case 2: return RightDockWidgetArea;
case 4: return TopDockWidgetArea;
case 8: return BottomDockWidgetArea;
case 15: return DockWidgetArea_Mask;
case 0: return NoDockWidgetArea;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link DockWidgetArea}
*/
public static final class DockWidgetAreas extends QFlags implements Comparable {
private static final long serialVersionUID = 0x552b51f58f9b406cL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new DockWidgetAreas where the flags in args are set.
* @param args enum entries
*/
public DockWidgetAreas(@Nullable DockWidgetArea @NonNull... args){
super(args);
}
/**
* Creates a new DockWidgetAreas with given value.
* @param value
*/
public DockWidgetAreas(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new DockWidgetAreas
*/
@Override
public final @NonNull DockWidgetAreas combined(@StrictNonNull DockWidgetArea e){
return new DockWidgetAreas(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull DockWidgetAreas setFlag(@Nullable DockWidgetArea e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull DockWidgetAreas setFlag(@Nullable DockWidgetArea e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this DockWidgetAreas.
* @return array of enum entries
*/
@Override
public final @NonNull DockWidgetArea @NonNull[] flags(){
return super.flags(DockWidgetArea.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull DockWidgetAreas clone(){
return new DockWidgetAreas(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull DockWidgetAreas other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::DockWidgetAreaSizes
*/
@QtUnlistedEnum
public enum DockWidgetAreaSizes implements QtEnumerator {
/**
* Representing Qt::
*/
NDockWidgetAreas(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private DockWidgetAreaSizes(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull DockWidgetAreaSizes resolve(int value) {
switch (value) {
case 4: return NDockWidgetAreas;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::DropAction
*
* @see DropActions
*/
public enum DropAction implements QtFlagEnumerator {
/**
* Representing Qt::
*/
CopyAction(1),
/**
* Representing Qt::
*/
MoveAction(2),
/**
* Representing Qt::
*/
LinkAction(4),
/**
* Representing Qt::
*/
ActionMask(255),
/**
* Representing Qt::
*/
TargetMoveAction(32770),
/**
* Representing Qt::
*/
IgnoreAction(0);
static {
QtJambi_LibraryUtilities.initialize();
}
private DropAction(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull DropActions asFlags() {
return new DropActions(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull DropActions combined(@NonNull DropAction e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull DropActions cleared(@NonNull DropAction e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link DropActions} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull DropActions flags(@Nullable DropAction @NonNull... values) {
return new DropActions(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull DropAction resolve(int value) {
switch (value) {
case 1: return CopyAction;
case 2: return MoveAction;
case 4: return LinkAction;
case 255: return ActionMask;
case 32770: return TargetMoveAction;
case 0: return IgnoreAction;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link DropAction}
*/
public static final class DropActions extends QFlags implements Comparable {
private static final long serialVersionUID = 0xadd267923fb12d1cL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new DropActions where the flags in args are set.
* @param args enum entries
*/
public DropActions(@Nullable DropAction @NonNull... args){
super(args);
}
/**
* Creates a new DropActions with given value.
* @param value
*/
public DropActions(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new DropActions
*/
@Override
public final @NonNull DropActions combined(@StrictNonNull DropAction e){
return new DropActions(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull DropActions setFlag(@Nullable DropAction e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull DropActions setFlag(@Nullable DropAction e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this DropActions.
* @return array of enum entries
*/
@Override
public final @NonNull DropAction @NonNull[] flags(){
return super.flags(DropAction.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull DropActions clone(){
return new DropActions(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull DropActions other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::Edge
*
* @see Edges
*/
public enum Edge implements QtFlagEnumerator {
/**
* Representing Qt::
*/
TopEdge(1),
/**
* Representing Qt::
*/
LeftEdge(2),
/**
* Representing Qt::
*/
RightEdge(4),
/**
* Representing Qt::
*/
BottomEdge(8);
static {
QtJambi_LibraryUtilities.initialize();
}
private Edge(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull Edges asFlags() {
return new Edges(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Edges combined(@NonNull Edge e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Edges cleared(@NonNull Edge e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link Edges} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull Edges flags(@Nullable Edge @NonNull... values) {
return new Edges(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull Edge resolve(int value) {
switch (value) {
case 1: return TopEdge;
case 2: return LeftEdge;
case 4: return RightEdge;
case 8: return BottomEdge;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link Edge}
*/
public static final class Edges extends QFlags implements Comparable {
private static final long serialVersionUID = 0x20fd89038447ec2dL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new Edges where the flags in args are set.
* @param args enum entries
*/
public Edges(@Nullable Edge @NonNull... args){
super(args);
}
/**
* Creates a new Edges with given value.
* @param value
*/
public Edges(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new Edges
*/
@Override
public final @NonNull Edges combined(@StrictNonNull Edge e){
return new Edges(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull Edges setFlag(@Nullable Edge e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull Edges setFlag(@Nullable Edge e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this Edges.
* @return array of enum entries
*/
@Override
public final @NonNull Edge @NonNull[] flags(){
return super.flags(Edge.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull Edges clone(){
return new Edges(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull Edges other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::EnterKeyType
*/
public enum EnterKeyType implements QtEnumerator {
/**
* Representing Qt::
*/
EnterKeyDefault(0),
/**
* Representing Qt::
*/
EnterKeyReturn(1),
/**
* Representing Qt::
*/
EnterKeyDone(2),
/**
* Representing Qt::
*/
EnterKeyGo(3),
/**
* Representing Qt::
*/
EnterKeySend(4),
/**
* Representing Qt::
*/
EnterKeySearch(5),
/**
* Representing Qt::
*/
EnterKeyNext(6),
/**
* Representing Qt::
*/
EnterKeyPrevious(7);
static {
QtJambi_LibraryUtilities.initialize();
}
private EnterKeyType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull EnterKeyType resolve(int value) {
switch (value) {
case 0: return EnterKeyDefault;
case 1: return EnterKeyReturn;
case 2: return EnterKeyDone;
case 3: return EnterKeyGo;
case 4: return EnterKeySend;
case 5: return EnterKeySearch;
case 6: return EnterKeyNext;
case 7: return EnterKeyPrevious;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::EventPriority
*/
@QtUnlistedEnum
public enum EventPriority implements QtEnumerator {
/**
* Representing Qt::
*/
HighEventPriority(1),
/**
* Representing Qt::
*/
NormalEventPriority(0),
/**
* Representing Qt::
*/
LowEventPriority(-1);
static {
QtJambi_LibraryUtilities.initialize();
}
private EventPriority(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull EventPriority resolve(int value) {
switch (value) {
case 1: return HighEventPriority;
case 0: return NormalEventPriority;
case -1: return LowEventPriority;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::FillRule
*/
public enum FillRule implements QtEnumerator {
/**
* Representing Qt::
*/
OddEvenFill(0),
/**
* Representing Qt::
*/
WindingFill(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private FillRule(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull FillRule resolve(int value) {
switch (value) {
case 0: return OddEvenFill;
case 1: return WindingFill;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::FindChildOption
*
* @see FindChildOptions
*/
public enum FindChildOption implements QtFlagEnumerator {
/**
* Representing Qt::
*/
FindDirectChildrenOnly(0),
/**
* Representing Qt::
*/
FindChildrenRecursively(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private FindChildOption(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull FindChildOptions asFlags() {
return new FindChildOptions(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull FindChildOptions combined(@NonNull FindChildOption e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull FindChildOptions cleared(@NonNull FindChildOption e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link FindChildOptions} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull FindChildOptions flags(@Nullable FindChildOption @NonNull... values) {
return new FindChildOptions(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull FindChildOption resolve(int value) {
switch (value) {
case 0: return FindDirectChildrenOnly;
case 1: return FindChildrenRecursively;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link FindChildOption}
*/
public static final class FindChildOptions extends QFlags implements Comparable {
private static final long serialVersionUID = 0x77feb73874bdf5baL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new FindChildOptions where the flags in args are set.
* @param args enum entries
*/
public FindChildOptions(@Nullable FindChildOption @NonNull... args){
super(args);
}
/**
* Creates a new FindChildOptions with given value.
* @param value
*/
public FindChildOptions(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new FindChildOptions
*/
@Override
public final @NonNull FindChildOptions combined(@StrictNonNull FindChildOption e){
return new FindChildOptions(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull FindChildOptions setFlag(@Nullable FindChildOption e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull FindChildOptions setFlag(@Nullable FindChildOption e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this FindChildOptions.
* @return array of enum entries
*/
@Override
public final @NonNull FindChildOption @NonNull[] flags(){
return super.flags(FindChildOption.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull FindChildOptions clone(){
return new FindChildOptions(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull FindChildOptions other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::FocusPolicy
*/
public enum FocusPolicy implements QtEnumerator {
/**
* Representing Qt::
*/
NoFocus(0),
/**
* Representing Qt::
*/
TabFocus(1),
/**
* Representing Qt::
*/
ClickFocus(2),
/**
* Representing Qt::
*/
StrongFocus(11),
/**
* Representing Qt::
*/
WheelFocus(15);
static {
QtJambi_LibraryUtilities.initialize();
}
private FocusPolicy(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull FocusPolicy resolve(int value) {
switch (value) {
case 0: return NoFocus;
case 1: return TabFocus;
case 2: return ClickFocus;
case 11: return StrongFocus;
case 15: return WheelFocus;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::FocusReason
*/
public enum FocusReason implements QtEnumerator {
/**
* Representing Qt::
*/
MouseFocusReason(0),
/**
* Representing Qt::
*/
TabFocusReason(1),
/**
* Representing Qt::
*/
BacktabFocusReason(2),
/**
* Representing Qt::
*/
ActiveWindowFocusReason(3),
/**
* Representing Qt::
*/
PopupFocusReason(4),
/**
* Representing Qt::
*/
ShortcutFocusReason(5),
/**
* Representing Qt::
*/
MenuBarFocusReason(6),
/**
* Representing Qt::
*/
OtherFocusReason(7),
/**
* Representing Qt::
*/
NoFocusReason(8);
static {
QtJambi_LibraryUtilities.initialize();
}
private FocusReason(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull FocusReason resolve(int value) {
switch (value) {
case 0: return MouseFocusReason;
case 1: return TabFocusReason;
case 2: return BacktabFocusReason;
case 3: return ActiveWindowFocusReason;
case 4: return PopupFocusReason;
case 5: return ShortcutFocusReason;
case 6: return MenuBarFocusReason;
case 7: return OtherFocusReason;
case 8: return NoFocusReason;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::GestureFlag
*
* @see GestureFlags
*/
public enum GestureFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
DontStartGestureOnChildren(1),
/**
* Representing Qt::
*/
ReceivePartialGestures(2),
/**
* Representing Qt::
*/
IgnoredGesturesPropagateToParent(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private GestureFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull GestureFlags asFlags() {
return new GestureFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull GestureFlags combined(@NonNull GestureFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull GestureFlags cleared(@NonNull GestureFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link GestureFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull GestureFlags flags(@Nullable GestureFlag @NonNull... values) {
return new GestureFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull GestureFlag resolve(int value) {
switch (value) {
case 1: return DontStartGestureOnChildren;
case 2: return ReceivePartialGestures;
case 4: return IgnoredGesturesPropagateToParent;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link GestureFlag}
*/
public static final class GestureFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0xcf327bb14988470aL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new GestureFlags where the flags in args are set.
* @param args enum entries
*/
public GestureFlags(@Nullable GestureFlag @NonNull... args){
super(args);
}
/**
* Creates a new GestureFlags with given value.
* @param value
*/
public GestureFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new GestureFlags
*/
@Override
public final @NonNull GestureFlags combined(@StrictNonNull GestureFlag e){
return new GestureFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull GestureFlags setFlag(@Nullable GestureFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull GestureFlags setFlag(@Nullable GestureFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this GestureFlags.
* @return array of enum entries
*/
@Override
public final @NonNull GestureFlag @NonNull[] flags(){
return super.flags(GestureFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull GestureFlags clone(){
return new GestureFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull GestureFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::GestureState
*/
public enum GestureState implements QtEnumerator {
/**
* Representing Qt::
*/
NoGesture(0),
/**
* Representing Qt::
*/
GestureStarted(1),
/**
* Representing Qt::
*/
GestureUpdated(2),
/**
* Representing Qt::
*/
GestureFinished(3),
/**
* Representing Qt::
*/
GestureCanceled(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private GestureState(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull GestureState resolve(int value) {
switch (value) {
case 0: return NoGesture;
case 1: return GestureStarted;
case 2: return GestureUpdated;
case 3: return GestureFinished;
case 4: return GestureCanceled;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::GestureType
*/
public enum GestureType implements QtEnumerator {
/**
* Representing Qt::
*/
TapGesture(1),
/**
* Representing Qt::
*/
TapAndHoldGesture(2),
/**
* Representing Qt::
*/
PanGesture(3),
/**
* Representing Qt::
*/
PinchGesture(4),
/**
* Representing Qt::
*/
SwipeGesture(5),
/**
* Representing Qt::
*/
CustomGesture(256),
/**
* Representing Qt::
*/
LastGestureType(-1);
static {
QtJambi_LibraryUtilities.initialize();
}
private GestureType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull GestureType resolve(int value) {
switch (value) {
case 1: return TapGesture;
case 2: return TapAndHoldGesture;
case 3: return PanGesture;
case 4: return PinchGesture;
case 5: return SwipeGesture;
case 256: return CustomGesture;
case -1: return LastGestureType;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::GlobalColor
*/
public enum GlobalColor implements QtEnumerator {
/**
* Representing Qt::
*/
color0(0),
/**
* Representing Qt::
*/
color1(1),
/**
* Representing Qt::
*/
black(2),
/**
* Representing Qt::
*/
white(3),
/**
* Representing Qt::
*/
darkGray(4),
/**
* Representing Qt::
*/
gray(5),
/**
* Representing Qt::
*/
lightGray(6),
/**
* Representing Qt::
*/
red(7),
/**
* Representing Qt::
*/
green(8),
/**
* Representing Qt::
*/
blue(9),
/**
* Representing Qt::
*/
cyan(10),
/**
* Representing Qt::
*/
magenta(11),
/**
* Representing Qt::
*/
yellow(12),
/**
* Representing Qt::
*/
darkRed(13),
/**
* Representing Qt::
*/
darkGreen(14),
/**
* Representing Qt::
*/
darkBlue(15),
/**
* Representing Qt::
*/
darkCyan(16),
/**
* Representing Qt::
*/
darkMagenta(17),
/**
* Representing Qt::
*/
darkYellow(18),
/**
* Representing Qt::
*/
transparent(19);
static {
QtJambi_LibraryUtilities.initialize();
}
private GlobalColor(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull GlobalColor resolve(int value) {
switch (value) {
case 0: return color0;
case 1: return color1;
case 2: return black;
case 3: return white;
case 4: return darkGray;
case 5: return gray;
case 6: return lightGray;
case 7: return red;
case 8: return green;
case 9: return blue;
case 10: return cyan;
case 11: return magenta;
case 12: return yellow;
case 13: return darkRed;
case 14: return darkGreen;
case 15: return darkBlue;
case 16: return darkCyan;
case 17: return darkMagenta;
case 18: return darkYellow;
case 19: return transparent;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::HighDpiScaleFactorRoundingPolicy
*/
public enum HighDpiScaleFactorRoundingPolicy implements QtEnumerator {
/**
* Representing Qt::
*/
Unset(0),
/**
* Representing Qt::
*/
Round(1),
/**
* Representing Qt::
*/
Ceil(2),
/**
* Representing Qt::
*/
Floor(3),
/**
* Representing Qt::
*/
RoundPreferFloor(4),
/**
* Representing Qt::
*/
PassThrough(5);
static {
QtJambi_LibraryUtilities.initialize();
}
private HighDpiScaleFactorRoundingPolicy(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull HighDpiScaleFactorRoundingPolicy resolve(int value) {
switch (value) {
case 0: return Unset;
case 1: return Round;
case 2: return Ceil;
case 3: return Floor;
case 4: return RoundPreferFloor;
case 5: return PassThrough;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::HitTestAccuracy
*/
@QtUnlistedEnum
public enum HitTestAccuracy implements QtEnumerator {
/**
* Representing Qt::
*/
ExactHit(0),
/**
* Representing Qt::
*/
FuzzyHit(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private HitTestAccuracy(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull HitTestAccuracy resolve(int value) {
switch (value) {
case 0: return ExactHit;
case 1: return FuzzyHit;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ImageConversionFlag
*
* @see ImageConversionFlags
*/
@QtRejectedEntries({"ColorOnly", "ThresholdAlphaDither", "NoAlpha", "DiffuseDither", "AutoDither"})
public enum ImageConversionFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
ColorMode_Mask(3),
/**
* Representing Qt::
*/
AutoColor(0),
/**
* Representing Qt::
*/
ColorOnly(3),
/**
* Representing Qt::
*/
MonoOnly(2),
/**
* Representing Qt::
*/
AlphaDither_Mask(12),
/**
* Representing Qt::
*/
ThresholdAlphaDither(0),
/**
* Representing Qt::
*/
OrderedAlphaDither(4),
/**
* Representing Qt::
*/
DiffuseAlphaDither(8),
/**
* Representing Qt::
*/
NoAlpha(12),
/**
* Representing Qt::
*/
Dither_Mask(48),
/**
* Representing Qt::
*/
DiffuseDither(0),
/**
* Representing Qt::
*/
OrderedDither(16),
/**
* Representing Qt::
*/
ThresholdDither(32),
/**
* Representing Qt::
*/
DitherMode_Mask(192),
/**
* Representing Qt::
*/
AutoDither(0),
/**
* Representing Qt::
*/
PreferDither(64),
/**
* Representing Qt::
*/
AvoidDither(128),
/**
* Representing Qt::
*/
NoOpaqueDetection(256),
/**
* Representing Qt::
*/
NoFormatConversion(512);
static {
QtJambi_LibraryUtilities.initialize();
}
private ImageConversionFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull ImageConversionFlags asFlags() {
return new ImageConversionFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ImageConversionFlags combined(@NonNull ImageConversionFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ImageConversionFlags cleared(@NonNull ImageConversionFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link ImageConversionFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull ImageConversionFlags flags(@Nullable ImageConversionFlag @NonNull... values) {
return new ImageConversionFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ImageConversionFlag resolve(int value) {
switch (value) {
case 3: return ColorMode_Mask;
case 0: return AutoColor;
case 2: return MonoOnly;
case 12: return AlphaDither_Mask;
case 4: return OrderedAlphaDither;
case 8: return DiffuseAlphaDither;
case 48: return Dither_Mask;
case 16: return OrderedDither;
case 32: return ThresholdDither;
case 192: return DitherMode_Mask;
case 64: return PreferDither;
case 128: return AvoidDither;
case 256: return NoOpaqueDetection;
case 512: return NoFormatConversion;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link ImageConversionFlag}
*/
public static final class ImageConversionFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0x42fe882ed9d09702L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new ImageConversionFlags where the flags in args are set.
* @param args enum entries
*/
public ImageConversionFlags(@Nullable ImageConversionFlag @NonNull... args){
super(args);
}
/**
* Creates a new ImageConversionFlags with given value.
* @param value
*/
public ImageConversionFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new ImageConversionFlags
*/
@Override
public final @NonNull ImageConversionFlags combined(@StrictNonNull ImageConversionFlag e){
return new ImageConversionFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull ImageConversionFlags setFlag(@Nullable ImageConversionFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull ImageConversionFlags setFlag(@Nullable ImageConversionFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this ImageConversionFlags.
* @return array of enum entries
*/
@Override
public final @NonNull ImageConversionFlag @NonNull[] flags(){
return super.flags(ImageConversionFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull ImageConversionFlags clone(){
return new ImageConversionFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull ImageConversionFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::InputMethodHint
*
* @see InputMethodHints
*/
public enum InputMethodHint implements QtFlagEnumerator {
/**
* Representing Qt::
*/
ImhNone(0),
/**
* Representing Qt::
*/
ImhHiddenText(1),
/**
* Representing Qt::
*/
ImhSensitiveData(2),
/**
* Representing Qt::
*/
ImhNoAutoUppercase(4),
/**
* Representing Qt::
*/
ImhPreferNumbers(8),
/**
* Representing Qt::
*/
ImhPreferUppercase(16),
/**
* Representing Qt::
*/
ImhPreferLowercase(32),
/**
* Representing Qt::
*/
ImhNoPredictiveText(64),
/**
* Representing Qt::
*/
ImhDate(128),
/**
* Representing Qt::
*/
ImhTime(256),
/**
* Representing Qt::
*/
ImhPreferLatin(512),
/**
* Representing Qt::
*/
ImhMultiLine(1024),
/**
* Representing Qt::
*/
ImhNoEditMenu(2048),
/**
* Representing Qt::
*/
ImhNoTextHandles(4096),
/**
* Representing Qt::
*/
ImhDigitsOnly(65536),
/**
* Representing Qt::
*/
ImhFormattedNumbersOnly(131072),
/**
* Representing Qt::
*/
ImhUppercaseOnly(262144),
/**
* Representing Qt::
*/
ImhLowercaseOnly(524288),
/**
* Representing Qt::
*/
ImhDialableCharactersOnly(1048576),
/**
* Representing Qt::
*/
ImhEmailCharactersOnly(2097152),
/**
* Representing Qt::
*/
ImhUrlCharactersOnly(4194304),
/**
* Representing Qt::
*/
ImhLatinOnly(8388608),
/**
* Representing Qt::
*/
ImhExclusiveInputMask(-65536);
static {
QtJambi_LibraryUtilities.initialize();
}
private InputMethodHint(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull InputMethodHints asFlags() {
return new InputMethodHints(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull InputMethodHints combined(@NonNull InputMethodHint e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull InputMethodHints cleared(@NonNull InputMethodHint e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link InputMethodHints} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull InputMethodHints flags(@Nullable InputMethodHint @NonNull... values) {
return new InputMethodHints(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull InputMethodHint resolve(int value) {
switch (value) {
case 0: return ImhNone;
case 1: return ImhHiddenText;
case 2: return ImhSensitiveData;
case 4: return ImhNoAutoUppercase;
case 8: return ImhPreferNumbers;
case 16: return ImhPreferUppercase;
case 32: return ImhPreferLowercase;
case 64: return ImhNoPredictiveText;
case 128: return ImhDate;
case 256: return ImhTime;
case 512: return ImhPreferLatin;
case 1024: return ImhMultiLine;
case 2048: return ImhNoEditMenu;
case 4096: return ImhNoTextHandles;
case 65536: return ImhDigitsOnly;
case 131072: return ImhFormattedNumbersOnly;
case 262144: return ImhUppercaseOnly;
case 524288: return ImhLowercaseOnly;
case 1048576: return ImhDialableCharactersOnly;
case 2097152: return ImhEmailCharactersOnly;
case 4194304: return ImhUrlCharactersOnly;
case 8388608: return ImhLatinOnly;
case -65536: return ImhExclusiveInputMask;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link InputMethodHint}
*/
public static final class InputMethodHints extends QFlags implements Comparable {
private static final long serialVersionUID = 0x422c18840ddc0d4bL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new InputMethodHints where the flags in args are set.
* @param args enum entries
*/
public InputMethodHints(@Nullable InputMethodHint @NonNull... args){
super(args);
}
/**
* Creates a new InputMethodHints with given value.
* @param value
*/
public InputMethodHints(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new InputMethodHints
*/
@Override
public final @NonNull InputMethodHints combined(@StrictNonNull InputMethodHint e){
return new InputMethodHints(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull InputMethodHints setFlag(@Nullable InputMethodHint e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull InputMethodHints setFlag(@Nullable InputMethodHint e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this InputMethodHints.
* @return array of enum entries
*/
@Override
public final @NonNull InputMethodHint @NonNull[] flags(){
return super.flags(InputMethodHint.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull InputMethodHints clone(){
return new InputMethodHints(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull InputMethodHints other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::InputMethodQuery
*
* @see InputMethodQueries
*/
public enum InputMethodQuery implements QtFlagEnumerator {
/**
* Representing Qt::
*/
ImEnabled(1),
/**
* Representing Qt::
*/
ImCursorRectangle(2),
/**
* Representing Qt::
*/
ImFont(4),
/**
* Representing Qt::
*/
ImCursorPosition(8),
/**
* Representing Qt::
*/
ImSurroundingText(16),
/**
* Representing Qt::
*/
ImCurrentSelection(32),
/**
* Representing Qt::
*/
ImMaximumTextLength(64),
/**
* Representing Qt::
*/
ImAnchorPosition(128),
/**
* Representing Qt::
*/
ImHints(256),
/**
* Representing Qt::
*/
ImPreferredLanguage(512),
/**
* Representing Qt::
*/
ImAbsolutePosition(1024),
/**
* Representing Qt::
*/
ImTextBeforeCursor(2048),
/**
* Representing Qt::
*/
ImTextAfterCursor(4096),
/**
* Representing Qt::
*/
ImEnterKeyType(8192),
/**
* Representing Qt::
*/
ImAnchorRectangle(16384),
/**
* Representing Qt::
*/
ImInputItemClipRectangle(32768),
/**
* Representing Qt::
*/
ImReadOnly(65536),
/**
* Representing Qt::
*/
ImPlatformData(-2147483648),
/**
* Representing Qt::
*/
ImQueryInput(16570),
/**
* Representing Qt::
*/
ImQueryAll(-1);
static {
QtJambi_LibraryUtilities.initialize();
}
private InputMethodQuery(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull InputMethodQueries asFlags() {
return new InputMethodQueries(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull InputMethodQueries combined(@NonNull InputMethodQuery e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull InputMethodQueries cleared(@NonNull InputMethodQuery e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link InputMethodQueries} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull InputMethodQueries flags(@Nullable InputMethodQuery @NonNull... values) {
return new InputMethodQueries(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull InputMethodQuery resolve(int value) {
switch (value) {
case 1: return ImEnabled;
case 2: return ImCursorRectangle;
case 4: return ImFont;
case 8: return ImCursorPosition;
case 16: return ImSurroundingText;
case 32: return ImCurrentSelection;
case 64: return ImMaximumTextLength;
case 128: return ImAnchorPosition;
case 256: return ImHints;
case 512: return ImPreferredLanguage;
case 1024: return ImAbsolutePosition;
case 2048: return ImTextBeforeCursor;
case 4096: return ImTextAfterCursor;
case 8192: return ImEnterKeyType;
case 16384: return ImAnchorRectangle;
case 32768: return ImInputItemClipRectangle;
case 65536: return ImReadOnly;
case -2147483648: return ImPlatformData;
case 16570: return ImQueryInput;
case -1: return ImQueryAll;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link InputMethodQuery}
*/
public static final class InputMethodQueries extends QFlags implements Comparable {
private static final long serialVersionUID = 0x8141066a98439968L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new InputMethodQueries where the flags in args are set.
* @param args enum entries
*/
public InputMethodQueries(@Nullable InputMethodQuery @NonNull... args){
super(args);
}
/**
* Creates a new InputMethodQueries with given value.
* @param value
*/
public InputMethodQueries(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new InputMethodQueries
*/
@Override
public final @NonNull InputMethodQueries combined(@StrictNonNull InputMethodQuery e){
return new InputMethodQueries(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull InputMethodQueries setFlag(@Nullable InputMethodQuery e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull InputMethodQueries setFlag(@Nullable InputMethodQuery e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this InputMethodQueries.
* @return array of enum entries
*/
@Override
public final @NonNull InputMethodQuery @NonNull[] flags(){
return super.flags(InputMethodQuery.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull InputMethodQueries clone(){
return new InputMethodQueries(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull InputMethodQueries other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::ItemDataRole
*/
public static class ItemDataRole{
static {
QtJambi_LibraryUtilities.initialize();
}
public static final int DisplayRole = 0;
public static final int DecorationRole = 1;
public static final int EditRole = 2;
public static final int ToolTipRole = 3;
public static final int StatusTipRole = 4;
public static final int WhatsThisRole = 5;
public static final int FontRole = 6;
public static final int TextAlignmentRole = 7;
public static final int BackgroundRole = 8;
public static final int ForegroundRole = 9;
public static final int CheckStateRole = 10;
public static final int AccessibleTextRole = 11;
public static final int AccessibleDescriptionRole = 12;
public static final int SizeHintRole = 13;
public static final int InitialSortOrderRole = 14;
public static final int DisplayPropertyRole = 27;
public static final int DecorationPropertyRole = 28;
public static final int ToolTipPropertyRole = 29;
public static final int StatusTipPropertyRole = 30;
public static final int WhatsThisPropertyRole = 31;
public static final int UserRole = 256;
} // end of enum ItemDataRole
/**
* Java wrapper for Qt enum Qt::ItemFlag
*
* @see ItemFlags
*/
public enum ItemFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
NoItemFlags(0),
/**
* Representing Qt::
*/
ItemIsSelectable(1),
/**
* Representing Qt::
*/
ItemIsEditable(2),
/**
* Representing Qt::
*/
ItemIsDragEnabled(4),
/**
* Representing Qt::
*/
ItemIsDropEnabled(8),
/**
* Representing Qt::
*/
ItemIsUserCheckable(16),
/**
* Representing Qt::
*/
ItemIsEnabled(32),
/**
* Representing Qt::
*/
ItemIsAutoTristate(64),
/**
* Representing Qt::
*/
ItemNeverHasChildren(128),
/**
* Representing Qt::
*/
ItemIsUserTristate(256);
static {
QtJambi_LibraryUtilities.initialize();
}
private ItemFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull ItemFlags asFlags() {
return new ItemFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ItemFlags combined(@NonNull ItemFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ItemFlags cleared(@NonNull ItemFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link ItemFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull ItemFlags flags(@Nullable ItemFlag @NonNull... values) {
return new ItemFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ItemFlag resolve(int value) {
switch (value) {
case 0: return NoItemFlags;
case 1: return ItemIsSelectable;
case 2: return ItemIsEditable;
case 4: return ItemIsDragEnabled;
case 8: return ItemIsDropEnabled;
case 16: return ItemIsUserCheckable;
case 32: return ItemIsEnabled;
case 64: return ItemIsAutoTristate;
case 128: return ItemNeverHasChildren;
case 256: return ItemIsUserTristate;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link ItemFlag}
*/
public static final class ItemFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0x931af29c02ccfee8L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new ItemFlags where the flags in args are set.
* @param args enum entries
*/
public ItemFlags(@Nullable ItemFlag @NonNull... args){
super(args);
}
/**
* Creates a new ItemFlags with given value.
* @param value
*/
public ItemFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new ItemFlags
*/
@Override
public final @NonNull ItemFlags combined(@StrictNonNull ItemFlag e){
return new ItemFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull ItemFlags setFlag(@Nullable ItemFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull ItemFlags setFlag(@Nullable ItemFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this ItemFlags.
* @return array of enum entries
*/
@Override
public final @NonNull ItemFlag @NonNull[] flags(){
return super.flags(ItemFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull ItemFlags clone(){
return new ItemFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull ItemFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::ItemSelectionMode
*/
public enum ItemSelectionMode implements QtEnumerator {
/**
* Representing Qt::
*/
ContainsItemShape(0),
/**
* Representing Qt::
*/
IntersectsItemShape(1),
/**
* Representing Qt::
*/
ContainsItemBoundingRect(2),
/**
* Representing Qt::
*/
IntersectsItemBoundingRect(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private ItemSelectionMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ItemSelectionMode resolve(int value) {
switch (value) {
case 0: return ContainsItemShape;
case 1: return IntersectsItemShape;
case 2: return ContainsItemBoundingRect;
case 3: return IntersectsItemBoundingRect;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ItemSelectionOperation
*/
public enum ItemSelectionOperation implements QtEnumerator {
/**
* Representing Qt::
*/
ReplaceSelection(0),
/**
* Representing Qt::
*/
AddToSelection(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private ItemSelectionOperation(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ItemSelectionOperation resolve(int value) {
switch (value) {
case 0: return ReplaceSelection;
case 1: return AddToSelection;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::Key
*/
@QtRejectedEntries({"Key_Any", "Key_micro"})
public enum Key implements QtEnumerator {
/**
* Representing Qt::
*/
Key_Space(32),
/**
* Representing Qt::
*/
Key_Any(32),
/**
* Representing Qt::
*/
Key_Exclam(33),
/**
* Representing Qt::
*/
Key_QuoteDbl(34),
/**
* Representing Qt::
*/
Key_NumberSign(35),
/**
* Representing Qt::
*/
Key_Dollar(36),
/**
* Representing Qt::
*/
Key_Percent(37),
/**
* Representing Qt::
*/
Key_Ampersand(38),
/**
* Representing Qt::
*/
Key_Apostrophe(39),
/**
* Representing Qt::
*/
Key_ParenLeft(40),
/**
* Representing Qt::
*/
Key_ParenRight(41),
/**
* Representing Qt::
*/
Key_Asterisk(42),
/**
* Representing Qt::
*/
Key_Plus(43),
/**
* Representing Qt::
*/
Key_Comma(44),
/**
* Representing Qt::
*/
Key_Minus(45),
/**
* Representing Qt::
*/
Key_Period(46),
/**
* Representing Qt::
*/
Key_Slash(47),
/**
* Representing Qt::
*/
Key_0(48),
/**
* Representing Qt::
*/
Key_1(49),
/**
* Representing Qt::
*/
Key_2(50),
/**
* Representing Qt::
*/
Key_3(51),
/**
* Representing Qt::
*/
Key_4(52),
/**
* Representing Qt::
*/
Key_5(53),
/**
* Representing Qt::
*/
Key_6(54),
/**
* Representing Qt::
*/
Key_7(55),
/**
* Representing Qt::
*/
Key_8(56),
/**
* Representing Qt::
*/
Key_9(57),
/**
* Representing Qt::
*/
Key_Colon(58),
/**
* Representing Qt::
*/
Key_Semicolon(59),
/**
* Representing Qt::
*/
Key_Less(60),
/**
* Representing Qt::
*/
Key_Equal(61),
/**
* Representing Qt::
*/
Key_Greater(62),
/**
* Representing Qt::
*/
Key_Question(63),
/**
* Representing Qt::
*/
Key_At(64),
/**
* Representing Qt::
*/
Key_A(65),
/**
* Representing Qt::
*/
Key_B(66),
/**
* Representing Qt::
*/
Key_C(67),
/**
* Representing Qt::
*/
Key_D(68),
/**
* Representing Qt::
*/
Key_E(69),
/**
* Representing Qt::
*/
Key_F(70),
/**
* Representing Qt::
*/
Key_G(71),
/**
* Representing Qt::
*/
Key_H(72),
/**
* Representing Qt::
*/
Key_I(73),
/**
* Representing Qt::
*/
Key_J(74),
/**
* Representing Qt::
*/
Key_K(75),
/**
* Representing Qt::
*/
Key_L(76),
/**
* Representing Qt::
*/
Key_M(77),
/**
* Representing Qt::
*/
Key_N(78),
/**
* Representing Qt::
*/
Key_O(79),
/**
* Representing Qt::
*/
Key_P(80),
/**
* Representing Qt::
*/
Key_Q(81),
/**
* Representing Qt::
*/
Key_R(82),
/**
* Representing Qt::
*/
Key_S(83),
/**
* Representing Qt::
*/
Key_T(84),
/**
* Representing Qt::
*/
Key_U(85),
/**
* Representing Qt::
*/
Key_V(86),
/**
* Representing Qt::
*/
Key_W(87),
/**
* Representing Qt::
*/
Key_X(88),
/**
* Representing Qt::
*/
Key_Y(89),
/**
* Representing Qt::
*/
Key_Z(90),
/**
* Representing Qt::
*/
Key_BracketLeft(91),
/**
* Representing Qt::
*/
Key_Backslash(92),
/**
* Representing Qt::
*/
Key_BracketRight(93),
/**
* Representing Qt::
*/
Key_AsciiCircum(94),
/**
* Representing Qt::
*/
Key_Underscore(95),
/**
* Representing Qt::
*/
Key_QuoteLeft(96),
/**
* Representing Qt::
*/
Key_BraceLeft(123),
/**
* Representing Qt::
*/
Key_Bar(124),
/**
* Representing Qt::
*/
Key_BraceRight(125),
/**
* Representing Qt::
*/
Key_AsciiTilde(126),
/**
* Representing Qt::
*/
Key_nobreakspace(160),
/**
* Representing Qt::
*/
Key_exclamdown(161),
/**
* Representing Qt::
*/
Key_cent(162),
/**
* Representing Qt::
*/
Key_sterling(163),
/**
* Representing Qt::
*/
Key_currency(164),
/**
* Representing Qt::
*/
Key_yen(165),
/**
* Representing Qt::
*/
Key_brokenbar(166),
/**
* Representing Qt::
*/
Key_section(167),
/**
* Representing Qt::
*/
Key_diaeresis(168),
/**
* Representing Qt::
*/
Key_copyright(169),
/**
* Representing Qt::
*/
Key_ordfeminine(170),
/**
* Representing Qt::
*/
Key_guillemotleft(171),
/**
* Representing Qt::
*/
Key_notsign(172),
/**
* Representing Qt::
*/
Key_hyphen(173),
/**
* Representing Qt::
*/
Key_registered(174),
/**
* Representing Qt::
*/
Key_macron(175),
/**
* Representing Qt::
*/
Key_degree(176),
/**
* Representing Qt::
*/
Key_plusminus(177),
/**
* Representing Qt::
*/
Key_twosuperior(178),
/**
* Representing Qt::
*/
Key_threesuperior(179),
/**
* Representing Qt::
*/
Key_acute(180),
/**
* Representing Qt::
*/
Key_micro(181),
@Deprecated
/**
* Representing Qt::
* @deprecated This key was misnamed, use Key_micro instead
*/
Key_mu(181),
/**
* Representing Qt::
*/
Key_paragraph(182),
/**
* Representing Qt::
*/
Key_periodcentered(183),
/**
* Representing Qt::
*/
Key_cedilla(184),
/**
* Representing Qt::
*/
Key_onesuperior(185),
/**
* Representing Qt::
*/
Key_masculine(186),
/**
* Representing Qt::
*/
Key_guillemotright(187),
/**
* Representing Qt::
*/
Key_onequarter(188),
/**
* Representing Qt::
*/
Key_onehalf(189),
/**
* Representing Qt::
*/
Key_threequarters(190),
/**
* Representing Qt::
*/
Key_questiondown(191),
/**
* Representing Qt::
*/
Key_Agrave(192),
/**
* Representing Qt::
*/
Key_Aacute(193),
/**
* Representing Qt::
*/
Key_Acircumflex(194),
/**
* Representing Qt::
*/
Key_Atilde(195),
/**
* Representing Qt::
*/
Key_Adiaeresis(196),
/**
* Representing Qt::
*/
Key_Aring(197),
/**
* Representing Qt::
*/
Key_AE(198),
/**
* Representing Qt::
*/
Key_Ccedilla(199),
/**
* Representing Qt::
*/
Key_Egrave(200),
/**
* Representing Qt::
*/
Key_Eacute(201),
/**
* Representing Qt::
*/
Key_Ecircumflex(202),
/**
* Representing Qt::
*/
Key_Ediaeresis(203),
/**
* Representing Qt::
*/
Key_Igrave(204),
/**
* Representing Qt::
*/
Key_Iacute(205),
/**
* Representing Qt::
*/
Key_Icircumflex(206),
/**
* Representing Qt::
*/
Key_Idiaeresis(207),
/**
* Representing Qt::
*/
Key_ETH(208),
/**
* Representing Qt::
*/
Key_Ntilde(209),
/**
* Representing Qt::
*/
Key_Ograve(210),
/**
* Representing Qt::
*/
Key_Oacute(211),
/**
* Representing Qt::
*/
Key_Ocircumflex(212),
/**
* Representing Qt::
*/
Key_Otilde(213),
/**
* Representing Qt::
*/
Key_Odiaeresis(214),
/**
* Representing Qt::
*/
Key_multiply(215),
/**
* Representing Qt::
*/
Key_Ooblique(216),
/**
* Representing Qt::
*/
Key_Ugrave(217),
/**
* Representing Qt::
*/
Key_Uacute(218),
/**
* Representing Qt::
*/
Key_Ucircumflex(219),
/**
* Representing Qt::
*/
Key_Udiaeresis(220),
/**
* Representing Qt::
*/
Key_Yacute(221),
/**
* Representing Qt::
*/
Key_THORN(222),
/**
* Representing Qt::
*/
Key_ssharp(223),
/**
* Representing Qt::
*/
Key_division(247),
/**
* Representing Qt::
*/
Key_ydiaeresis(255),
/**
* Representing Qt::
*/
Key_Escape(16777216),
/**
* Representing Qt::
*/
Key_Tab(16777217),
/**
* Representing Qt::
*/
Key_Backtab(16777218),
/**
* Representing Qt::
*/
Key_Backspace(16777219),
/**
* Representing Qt::
*/
Key_Return(16777220),
/**
* Representing Qt::
*/
Key_Enter(16777221),
/**
* Representing Qt::
*/
Key_Insert(16777222),
/**
* Representing Qt::
*/
Key_Delete(16777223),
/**
* Representing Qt::
*/
Key_Pause(16777224),
/**
* Representing Qt::
*/
Key_Print(16777225),
/**
* Representing Qt::
*/
Key_SysReq(16777226),
/**
* Representing Qt::
*/
Key_Clear(16777227),
/**
* Representing Qt::
*/
Key_Home(16777232),
/**
* Representing Qt::
*/
Key_End(16777233),
/**
* Representing Qt::
*/
Key_Left(16777234),
/**
* Representing Qt::
*/
Key_Up(16777235),
/**
* Representing Qt::
*/
Key_Right(16777236),
/**
* Representing Qt::
*/
Key_Down(16777237),
/**
* Representing Qt::
*/
Key_PageUp(16777238),
/**
* Representing Qt::
*/
Key_PageDown(16777239),
/**
* Representing Qt::
*/
Key_Shift(16777248),
/**
* Representing Qt::
*/
Key_Control(16777249),
/**
* Representing Qt::
*/
Key_Meta(16777250),
/**
* Representing Qt::
*/
Key_Alt(16777251),
/**
* Representing Qt::
*/
Key_CapsLock(16777252),
/**
* Representing Qt::
*/
Key_NumLock(16777253),
/**
* Representing Qt::
*/
Key_ScrollLock(16777254),
/**
* Representing Qt::
*/
Key_F1(16777264),
/**
* Representing Qt::
*/
Key_F2(16777265),
/**
* Representing Qt::
*/
Key_F3(16777266),
/**
* Representing Qt::
*/
Key_F4(16777267),
/**
* Representing Qt::
*/
Key_F5(16777268),
/**
* Representing Qt::
*/
Key_F6(16777269),
/**
* Representing Qt::
*/
Key_F7(16777270),
/**
* Representing Qt::
*/
Key_F8(16777271),
/**
* Representing Qt::
*/
Key_F9(16777272),
/**
* Representing Qt::
*/
Key_F10(16777273),
/**
* Representing Qt::
*/
Key_F11(16777274),
/**
* Representing Qt::
*/
Key_F12(16777275),
/**
* Representing Qt::
*/
Key_F13(16777276),
/**
* Representing Qt::
*/
Key_F14(16777277),
/**
* Representing Qt::
*/
Key_F15(16777278),
/**
* Representing Qt::
*/
Key_F16(16777279),
/**
* Representing Qt::
*/
Key_F17(16777280),
/**
* Representing Qt::
*/
Key_F18(16777281),
/**
* Representing Qt::
*/
Key_F19(16777282),
/**
* Representing Qt::
*/
Key_F20(16777283),
/**
* Representing Qt::
*/
Key_F21(16777284),
/**
* Representing Qt::
*/
Key_F22(16777285),
/**
* Representing Qt::
*/
Key_F23(16777286),
/**
* Representing Qt::
*/
Key_F24(16777287),
/**
* Representing Qt::
*/
Key_F25(16777288),
/**
* Representing Qt::
*/
Key_F26(16777289),
/**
* Representing Qt::
*/
Key_F27(16777290),
/**
* Representing Qt::
*/
Key_F28(16777291),
/**
* Representing Qt::
*/
Key_F29(16777292),
/**
* Representing Qt::
*/
Key_F30(16777293),
/**
* Representing Qt::
*/
Key_F31(16777294),
/**
* Representing Qt::
*/
Key_F32(16777295),
/**
* Representing Qt::
*/
Key_F33(16777296),
/**
* Representing Qt::
*/
Key_F34(16777297),
/**
* Representing Qt::
*/
Key_F35(16777298),
/**
* Representing Qt::
*/
Key_Super_L(16777299),
/**
* Representing Qt::
*/
Key_Super_R(16777300),
/**
* Representing Qt::
*/
Key_Menu(16777301),
/**
* Representing Qt::
*/
Key_Hyper_L(16777302),
/**
* Representing Qt::
*/
Key_Hyper_R(16777303),
/**
* Representing Qt::
*/
Key_Help(16777304),
/**
* Representing Qt::
*/
Key_Direction_L(16777305),
/**
* Representing Qt::
*/
Key_Direction_R(16777312),
/**
* Representing Qt::
*/
Key_AltGr(16781571),
/**
* Representing Qt::
*/
Key_Multi_key(16781600),
/**
* Representing Qt::
*/
Key_Codeinput(16781623),
/**
* Representing Qt::
*/
Key_SingleCandidate(16781628),
/**
* Representing Qt::
*/
Key_MultipleCandidate(16781629),
/**
* Representing Qt::
*/
Key_PreviousCandidate(16781630),
/**
* Representing Qt::
*/
Key_Mode_switch(16781694),
/**
* Representing Qt::
*/
Key_Kanji(16781601),
/**
* Representing Qt::
*/
Key_Muhenkan(16781602),
/**
* Representing Qt::
*/
Key_Henkan(16781603),
/**
* Representing Qt::
*/
Key_Romaji(16781604),
/**
* Representing Qt::
*/
Key_Hiragana(16781605),
/**
* Representing Qt::
*/
Key_Katakana(16781606),
/**
* Representing Qt::
*/
Key_Hiragana_Katakana(16781607),
/**
* Representing Qt::
*/
Key_Zenkaku(16781608),
/**
* Representing Qt::
*/
Key_Hankaku(16781609),
/**
* Representing Qt::
*/
Key_Zenkaku_Hankaku(16781610),
/**
* Representing Qt::
*/
Key_Touroku(16781611),
/**
* Representing Qt::
*/
Key_Massyo(16781612),
/**
* Representing Qt::
*/
Key_Kana_Lock(16781613),
/**
* Representing Qt::
*/
Key_Kana_Shift(16781614),
/**
* Representing Qt::
*/
Key_Eisu_Shift(16781615),
/**
* Representing Qt::
*/
Key_Eisu_toggle(16781616),
/**
* Representing Qt::
*/
Key_Hangul(16781617),
/**
* Representing Qt::
*/
Key_Hangul_Start(16781618),
/**
* Representing Qt::
*/
Key_Hangul_End(16781619),
/**
* Representing Qt::
*/
Key_Hangul_Hanja(16781620),
/**
* Representing Qt::
*/
Key_Hangul_Jamo(16781621),
/**
* Representing Qt::
*/
Key_Hangul_Romaja(16781622),
/**
* Representing Qt::
*/
Key_Hangul_Jeonja(16781624),
/**
* Representing Qt::
*/
Key_Hangul_Banja(16781625),
/**
* Representing Qt::
*/
Key_Hangul_PreHanja(16781626),
/**
* Representing Qt::
*/
Key_Hangul_PostHanja(16781627),
/**
* Representing Qt::
*/
Key_Hangul_Special(16781631),
/**
* Representing Qt::
*/
Key_Dead_Grave(16781904),
/**
* Representing Qt::
*/
Key_Dead_Acute(16781905),
/**
* Representing Qt::
*/
Key_Dead_Circumflex(16781906),
/**
* Representing Qt::
*/
Key_Dead_Tilde(16781907),
/**
* Representing Qt::
*/
Key_Dead_Macron(16781908),
/**
* Representing Qt::
*/
Key_Dead_Breve(16781909),
/**
* Representing Qt::
*/
Key_Dead_Abovedot(16781910),
/**
* Representing Qt::
*/
Key_Dead_Diaeresis(16781911),
/**
* Representing Qt::
*/
Key_Dead_Abovering(16781912),
/**
* Representing Qt::
*/
Key_Dead_Doubleacute(16781913),
/**
* Representing Qt::
*/
Key_Dead_Caron(16781914),
/**
* Representing Qt::
*/
Key_Dead_Cedilla(16781915),
/**
* Representing Qt::
*/
Key_Dead_Ogonek(16781916),
/**
* Representing Qt::
*/
Key_Dead_Iota(16781917),
/**
* Representing Qt::
*/
Key_Dead_Voiced_Sound(16781918),
/**
* Representing Qt::
*/
Key_Dead_Semivoiced_Sound(16781919),
/**
* Representing Qt::
*/
Key_Dead_Belowdot(16781920),
/**
* Representing Qt::
*/
Key_Dead_Hook(16781921),
/**
* Representing Qt::
*/
Key_Dead_Horn(16781922),
/**
* Representing Qt::
*/
Key_Dead_Stroke(16781923),
/**
* Representing Qt::
*/
Key_Dead_Abovecomma(16781924),
/**
* Representing Qt::
*/
Key_Dead_Abovereversedcomma(16781925),
/**
* Representing Qt::
*/
Key_Dead_Doublegrave(16781926),
/**
* Representing Qt::
*/
Key_Dead_Belowring(16781927),
/**
* Representing Qt::
*/
Key_Dead_Belowmacron(16781928),
/**
* Representing Qt::
*/
Key_Dead_Belowcircumflex(16781929),
/**
* Representing Qt::
*/
Key_Dead_Belowtilde(16781930),
/**
* Representing Qt::
*/
Key_Dead_Belowbreve(16781931),
/**
* Representing Qt::
*/
Key_Dead_Belowdiaeresis(16781932),
/**
* Representing Qt::
*/
Key_Dead_Invertedbreve(16781933),
/**
* Representing Qt::
*/
Key_Dead_Belowcomma(16781934),
/**
* Representing Qt::
*/
Key_Dead_Currency(16781935),
/**
* Representing Qt::
*/
Key_Dead_a(16781952),
/**
* Representing Qt::
*/
Key_Dead_A(16781953),
/**
* Representing Qt::
*/
Key_Dead_e(16781954),
/**
* Representing Qt::
*/
Key_Dead_E(16781955),
/**
* Representing Qt::
*/
Key_Dead_i(16781956),
/**
* Representing Qt::
*/
Key_Dead_I(16781957),
/**
* Representing Qt::
*/
Key_Dead_o(16781958),
/**
* Representing Qt::
*/
Key_Dead_O(16781959),
/**
* Representing Qt::
*/
Key_Dead_u(16781960),
/**
* Representing Qt::
*/
Key_Dead_U(16781961),
/**
* Representing Qt::
*/
Key_Dead_Small_Schwa(16781962),
/**
* Representing Qt::
*/
Key_Dead_Capital_Schwa(16781963),
/**
* Representing Qt::
*/
Key_Dead_Greek(16781964),
/**
* Representing Qt::
*/
Key_Dead_Lowline(16781968),
/**
* Representing Qt::
*/
Key_Dead_Aboveverticalline(16781969),
/**
* Representing Qt::
*/
Key_Dead_Belowverticalline(16781970),
/**
* Representing Qt::
*/
Key_Dead_Longsolidusoverlay(16781971),
/**
* Representing Qt::
*/
Key_Back(16777313),
/**
* Representing Qt::
*/
Key_Forward(16777314),
/**
* Representing Qt::
*/
Key_Stop(16777315),
/**
* Representing Qt::
*/
Key_Refresh(16777316),
/**
* Representing Qt::
*/
Key_VolumeDown(16777328),
/**
* Representing Qt::
*/
Key_VolumeMute(16777329),
/**
* Representing Qt::
*/
Key_VolumeUp(16777330),
/**
* Representing Qt::
*/
Key_BassBoost(16777331),
/**
* Representing Qt::
*/
Key_BassUp(16777332),
/**
* Representing Qt::
*/
Key_BassDown(16777333),
/**
* Representing Qt::
*/
Key_TrebleUp(16777334),
/**
* Representing Qt::
*/
Key_TrebleDown(16777335),
/**
* Representing Qt::
*/
Key_MediaPlay(16777344),
/**
* Representing Qt::
*/
Key_MediaStop(16777345),
/**
* Representing Qt::
*/
Key_MediaPrevious(16777346),
/**
* Representing Qt::
*/
Key_MediaNext(16777347),
/**
* Representing Qt::
*/
Key_MediaRecord(16777348),
/**
* Representing Qt::
*/
Key_MediaPause(16777349),
/**
* Representing Qt::
*/
Key_MediaTogglePlayPause(16777350),
/**
* Representing Qt::
*/
Key_HomePage(16777360),
/**
* Representing Qt::
*/
Key_Favorites(16777361),
/**
* Representing Qt::
*/
Key_Search(16777362),
/**
* Representing Qt::
*/
Key_Standby(16777363),
/**
* Representing Qt::
*/
Key_OpenUrl(16777364),
/**
* Representing Qt::
*/
Key_LaunchMail(16777376),
/**
* Representing Qt::
*/
Key_LaunchMedia(16777377),
/**
* Representing Qt::
*/
Key_Launch0(16777378),
/**
* Representing Qt::
*/
Key_Launch1(16777379),
/**
* Representing Qt::
*/
Key_Launch2(16777380),
/**
* Representing Qt::
*/
Key_Launch3(16777381),
/**
* Representing Qt::
*/
Key_Launch4(16777382),
/**
* Representing Qt::
*/
Key_Launch5(16777383),
/**
* Representing Qt::
*/
Key_Launch6(16777384),
/**
* Representing Qt::
*/
Key_Launch7(16777385),
/**
* Representing Qt::
*/
Key_Launch8(16777386),
/**
* Representing Qt::
*/
Key_Launch9(16777387),
/**
* Representing Qt::
*/
Key_LaunchA(16777388),
/**
* Representing Qt::
*/
Key_LaunchB(16777389),
/**
* Representing Qt::
*/
Key_LaunchC(16777390),
/**
* Representing Qt::
*/
Key_LaunchD(16777391),
/**
* Representing Qt::
*/
Key_LaunchE(16777392),
/**
* Representing Qt::
*/
Key_LaunchF(16777393),
/**
* Representing Qt::
*/
Key_MonBrightnessUp(16777394),
/**
* Representing Qt::
*/
Key_MonBrightnessDown(16777395),
/**
* Representing Qt::
*/
Key_KeyboardLightOnOff(16777396),
/**
* Representing Qt::
*/
Key_KeyboardBrightnessUp(16777397),
/**
* Representing Qt::
*/
Key_KeyboardBrightnessDown(16777398),
/**
* Representing Qt::
*/
Key_PowerOff(16777399),
/**
* Representing Qt::
*/
Key_WakeUp(16777400),
/**
* Representing Qt::
*/
Key_Eject(16777401),
/**
* Representing Qt::
*/
Key_ScreenSaver(16777402),
/**
* Representing Qt::
*/
Key_WWW(16777403),
/**
* Representing Qt::
*/
Key_Memo(16777404),
/**
* Representing Qt::
*/
Key_LightBulb(16777405),
/**
* Representing Qt::
*/
Key_Shop(16777406),
/**
* Representing Qt::
*/
Key_History(16777407),
/**
* Representing Qt::
*/
Key_AddFavorite(16777408),
/**
* Representing Qt::
*/
Key_HotLinks(16777409),
/**
* Representing Qt::
*/
Key_BrightnessAdjust(16777410),
/**
* Representing Qt::
*/
Key_Finance(16777411),
/**
* Representing Qt::
*/
Key_Community(16777412),
/**
* Representing Qt::
*/
Key_AudioRewind(16777413),
/**
* Representing Qt::
*/
Key_BackForward(16777414),
/**
* Representing Qt::
*/
Key_ApplicationLeft(16777415),
/**
* Representing Qt::
*/
Key_ApplicationRight(16777416),
/**
* Representing Qt::
*/
Key_Book(16777417),
/**
* Representing Qt::
*/
Key_CD(16777418),
/**
* Representing Qt::
*/
Key_Calculator(16777419),
/**
* Representing Qt::
*/
Key_ToDoList(16777420),
/**
* Representing Qt::
*/
Key_ClearGrab(16777421),
/**
* Representing Qt::
*/
Key_Close(16777422),
/**
* Representing Qt::
*/
Key_Copy(16777423),
/**
* Representing Qt::
*/
Key_Cut(16777424),
/**
* Representing Qt::
*/
Key_Display(16777425),
/**
* Representing Qt::
*/
Key_DOS(16777426),
/**
* Representing Qt::
*/
Key_Documents(16777427),
/**
* Representing Qt::
*/
Key_Excel(16777428),
/**
* Representing Qt::
*/
Key_Explorer(16777429),
/**
* Representing Qt::
*/
Key_Game(16777430),
/**
* Representing Qt::
*/
Key_Go(16777431),
/**
* Representing Qt::
*/
Key_iTouch(16777432),
/**
* Representing Qt::
*/
Key_LogOff(16777433),
/**
* Representing Qt::
*/
Key_Market(16777434),
/**
* Representing Qt::
*/
Key_Meeting(16777435),
/**
* Representing Qt::
*/
Key_MenuKB(16777436),
/**
* Representing Qt::
*/
Key_MenuPB(16777437),
/**
* Representing Qt::
*/
Key_MySites(16777438),
/**
* Representing Qt::
*/
Key_News(16777439),
/**
* Representing Qt::
*/
Key_OfficeHome(16777440),
/**
* Representing Qt::
*/
Key_Option(16777441),
/**
* Representing Qt::
*/
Key_Paste(16777442),
/**
* Representing Qt::
*/
Key_Phone(16777443),
/**
* Representing Qt::
*/
Key_Calendar(16777444),
/**
* Representing Qt::
*/
Key_Reply(16777445),
/**
* Representing Qt::
*/
Key_Reload(16777446),
/**
* Representing Qt::
*/
Key_RotateWindows(16777447),
/**
* Representing Qt::
*/
Key_RotationPB(16777448),
/**
* Representing Qt::
*/
Key_RotationKB(16777449),
/**
* Representing Qt::
*/
Key_Save(16777450),
/**
* Representing Qt::
*/
Key_Send(16777451),
/**
* Representing Qt::
*/
Key_Spell(16777452),
/**
* Representing Qt::
*/
Key_SplitScreen(16777453),
/**
* Representing Qt::
*/
Key_Support(16777454),
/**
* Representing Qt::
*/
Key_TaskPane(16777455),
/**
* Representing Qt::
*/
Key_Terminal(16777456),
/**
* Representing Qt::
*/
Key_Tools(16777457),
/**
* Representing Qt::
*/
Key_Travel(16777458),
/**
* Representing Qt::
*/
Key_Video(16777459),
/**
* Representing Qt::
*/
Key_Word(16777460),
/**
* Representing Qt::
*/
Key_Xfer(16777461),
/**
* Representing Qt::
*/
Key_ZoomIn(16777462),
/**
* Representing Qt::
*/
Key_ZoomOut(16777463),
/**
* Representing Qt::
*/
Key_Away(16777464),
/**
* Representing Qt::
*/
Key_Messenger(16777465),
/**
* Representing Qt::
*/
Key_WebCam(16777466),
/**
* Representing Qt::
*/
Key_MailForward(16777467),
/**
* Representing Qt::
*/
Key_Pictures(16777468),
/**
* Representing Qt::
*/
Key_Music(16777469),
/**
* Representing Qt::
*/
Key_Battery(16777470),
/**
* Representing Qt::
*/
Key_Bluetooth(16777471),
/**
* Representing Qt::
*/
Key_WLAN(16777472),
/**
* Representing Qt::
*/
Key_UWB(16777473),
/**
* Representing Qt::
*/
Key_AudioForward(16777474),
/**
* Representing Qt::
*/
Key_AudioRepeat(16777475),
/**
* Representing Qt::
*/
Key_AudioRandomPlay(16777476),
/**
* Representing Qt::
*/
Key_Subtitle(16777477),
/**
* Representing Qt::
*/
Key_AudioCycleTrack(16777478),
/**
* Representing Qt::
*/
Key_Time(16777479),
/**
* Representing Qt::
*/
Key_Hibernate(16777480),
/**
* Representing Qt::
*/
Key_View(16777481),
/**
* Representing Qt::
*/
Key_TopMenu(16777482),
/**
* Representing Qt::
*/
Key_PowerDown(16777483),
/**
* Representing Qt::
*/
Key_Suspend(16777484),
/**
* Representing Qt::
*/
Key_ContrastAdjust(16777485),
/**
* Representing Qt::
*/
Key_LaunchG(16777486),
/**
* Representing Qt::
*/
Key_LaunchH(16777487),
/**
* Representing Qt::
*/
Key_TouchpadToggle(16777488),
/**
* Representing Qt::
*/
Key_TouchpadOn(16777489),
/**
* Representing Qt::
*/
Key_TouchpadOff(16777490),
/**
* Representing Qt::
*/
Key_MicMute(16777491),
/**
* Representing Qt::
*/
Key_Red(16777492),
/**
* Representing Qt::
*/
Key_Green(16777493),
/**
* Representing Qt::
*/
Key_Yellow(16777494),
/**
* Representing Qt::
*/
Key_Blue(16777495),
/**
* Representing Qt::
*/
Key_ChannelUp(16777496),
/**
* Representing Qt::
*/
Key_ChannelDown(16777497),
/**
* Representing Qt::
*/
Key_Guide(16777498),
/**
* Representing Qt::
*/
Key_Info(16777499),
/**
* Representing Qt::
*/
Key_Settings(16777500),
/**
* Representing Qt::
*/
Key_MicVolumeUp(16777501),
/**
* Representing Qt::
*/
Key_MicVolumeDown(16777502),
/**
* Representing Qt::
*/
Key_New(16777504),
/**
* Representing Qt::
*/
Key_Open(16777505),
/**
* Representing Qt::
*/
Key_Find(16777506),
/**
* Representing Qt::
*/
Key_Undo(16777507),
/**
* Representing Qt::
*/
Key_Redo(16777508),
/**
* Representing Qt::
*/
Key_MediaLast(16842751),
/**
* Representing Qt::
*/
Key_Select(16842752),
/**
* Representing Qt::
*/
Key_Yes(16842753),
/**
* Representing Qt::
*/
Key_No(16842754),
/**
* Representing Qt::
*/
Key_Cancel(16908289),
/**
* Representing Qt::
*/
Key_Printer(16908290),
/**
* Representing Qt::
*/
Key_Execute(16908291),
/**
* Representing Qt::
*/
Key_Sleep(16908292),
/**
* Representing Qt::
*/
Key_Play(16908293),
/**
* Representing Qt::
*/
Key_Zoom(16908294),
/**
* Representing Qt::
*/
Key_Exit(16908298),
/**
* Representing Qt::
*/
Key_Context1(17825792),
/**
* Representing Qt::
*/
Key_Context2(17825793),
/**
* Representing Qt::
*/
Key_Context3(17825794),
/**
* Representing Qt::
*/
Key_Context4(17825795),
/**
* Representing Qt::
*/
Key_Call(17825796),
/**
* Representing Qt::
*/
Key_Hangup(17825797),
/**
* Representing Qt::
*/
Key_Flip(17825798),
/**
* Representing Qt::
*/
Key_ToggleCallHangup(17825799),
/**
* Representing Qt::
*/
Key_VoiceDial(17825800),
/**
* Representing Qt::
*/
Key_LastNumberRedial(17825801),
/**
* Representing Qt::
*/
Key_Camera(17825824),
/**
* Representing Qt::
*/
Key_CameraFocus(17825825),
/**
* Representing Qt::
*/
Key_unknown(33554431);
static {
QtJambi_LibraryUtilities.initialize();
}
private Key(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull Key resolve(int value) {
switch (value) {
case 32: return Key_Space;
case 33: return Key_Exclam;
case 34: return Key_QuoteDbl;
case 35: return Key_NumberSign;
case 36: return Key_Dollar;
case 37: return Key_Percent;
case 38: return Key_Ampersand;
case 39: return Key_Apostrophe;
case 40: return Key_ParenLeft;
case 41: return Key_ParenRight;
case 42: return Key_Asterisk;
case 43: return Key_Plus;
case 44: return Key_Comma;
case 45: return Key_Minus;
case 46: return Key_Period;
case 47: return Key_Slash;
case 48: return Key_0;
case 49: return Key_1;
case 50: return Key_2;
case 51: return Key_3;
case 52: return Key_4;
case 53: return Key_5;
case 54: return Key_6;
case 55: return Key_7;
case 56: return Key_8;
case 57: return Key_9;
case 58: return Key_Colon;
case 59: return Key_Semicolon;
case 60: return Key_Less;
case 61: return Key_Equal;
case 62: return Key_Greater;
case 63: return Key_Question;
case 64: return Key_At;
case 65: return Key_A;
case 66: return Key_B;
case 67: return Key_C;
case 68: return Key_D;
case 69: return Key_E;
case 70: return Key_F;
case 71: return Key_G;
case 72: return Key_H;
case 73: return Key_I;
case 74: return Key_J;
case 75: return Key_K;
case 76: return Key_L;
case 77: return Key_M;
case 78: return Key_N;
case 79: return Key_O;
case 80: return Key_P;
case 81: return Key_Q;
case 82: return Key_R;
case 83: return Key_S;
case 84: return Key_T;
case 85: return Key_U;
case 86: return Key_V;
case 87: return Key_W;
case 88: return Key_X;
case 89: return Key_Y;
case 90: return Key_Z;
case 91: return Key_BracketLeft;
case 92: return Key_Backslash;
case 93: return Key_BracketRight;
case 94: return Key_AsciiCircum;
case 95: return Key_Underscore;
case 96: return Key_QuoteLeft;
case 123: return Key_BraceLeft;
case 124: return Key_Bar;
case 125: return Key_BraceRight;
case 126: return Key_AsciiTilde;
case 160: return Key_nobreakspace;
case 161: return Key_exclamdown;
case 162: return Key_cent;
case 163: return Key_sterling;
case 164: return Key_currency;
case 165: return Key_yen;
case 166: return Key_brokenbar;
case 167: return Key_section;
case 168: return Key_diaeresis;
case 169: return Key_copyright;
case 170: return Key_ordfeminine;
case 171: return Key_guillemotleft;
case 172: return Key_notsign;
case 173: return Key_hyphen;
case 174: return Key_registered;
case 175: return Key_macron;
case 176: return Key_degree;
case 177: return Key_plusminus;
case 178: return Key_twosuperior;
case 179: return Key_threesuperior;
case 180: return Key_acute;
case 181: return Key_mu;
case 182: return Key_paragraph;
case 183: return Key_periodcentered;
case 184: return Key_cedilla;
case 185: return Key_onesuperior;
case 186: return Key_masculine;
case 187: return Key_guillemotright;
case 188: return Key_onequarter;
case 189: return Key_onehalf;
case 190: return Key_threequarters;
case 191: return Key_questiondown;
case 192: return Key_Agrave;
case 193: return Key_Aacute;
case 194: return Key_Acircumflex;
case 195: return Key_Atilde;
case 196: return Key_Adiaeresis;
case 197: return Key_Aring;
case 198: return Key_AE;
case 199: return Key_Ccedilla;
case 200: return Key_Egrave;
case 201: return Key_Eacute;
case 202: return Key_Ecircumflex;
case 203: return Key_Ediaeresis;
case 204: return Key_Igrave;
case 205: return Key_Iacute;
case 206: return Key_Icircumflex;
case 207: return Key_Idiaeresis;
case 208: return Key_ETH;
case 209: return Key_Ntilde;
case 210: return Key_Ograve;
case 211: return Key_Oacute;
case 212: return Key_Ocircumflex;
case 213: return Key_Otilde;
case 214: return Key_Odiaeresis;
case 215: return Key_multiply;
case 216: return Key_Ooblique;
case 217: return Key_Ugrave;
case 218: return Key_Uacute;
case 219: return Key_Ucircumflex;
case 220: return Key_Udiaeresis;
case 221: return Key_Yacute;
case 222: return Key_THORN;
case 223: return Key_ssharp;
case 247: return Key_division;
case 255: return Key_ydiaeresis;
case 16777216: return Key_Escape;
case 16777217: return Key_Tab;
case 16777218: return Key_Backtab;
case 16777219: return Key_Backspace;
case 16777220: return Key_Return;
case 16777221: return Key_Enter;
case 16777222: return Key_Insert;
case 16777223: return Key_Delete;
case 16777224: return Key_Pause;
case 16777225: return Key_Print;
case 16777226: return Key_SysReq;
case 16777227: return Key_Clear;
case 16777232: return Key_Home;
case 16777233: return Key_End;
case 16777234: return Key_Left;
case 16777235: return Key_Up;
case 16777236: return Key_Right;
case 16777237: return Key_Down;
case 16777238: return Key_PageUp;
case 16777239: return Key_PageDown;
case 16777248: return Key_Shift;
case 16777249: return Key_Control;
case 16777250: return Key_Meta;
case 16777251: return Key_Alt;
case 16777252: return Key_CapsLock;
case 16777253: return Key_NumLock;
case 16777254: return Key_ScrollLock;
case 16777264: return Key_F1;
case 16777265: return Key_F2;
case 16777266: return Key_F3;
case 16777267: return Key_F4;
case 16777268: return Key_F5;
case 16777269: return Key_F6;
case 16777270: return Key_F7;
case 16777271: return Key_F8;
case 16777272: return Key_F9;
case 16777273: return Key_F10;
case 16777274: return Key_F11;
case 16777275: return Key_F12;
case 16777276: return Key_F13;
case 16777277: return Key_F14;
case 16777278: return Key_F15;
case 16777279: return Key_F16;
case 16777280: return Key_F17;
case 16777281: return Key_F18;
case 16777282: return Key_F19;
case 16777283: return Key_F20;
case 16777284: return Key_F21;
case 16777285: return Key_F22;
case 16777286: return Key_F23;
case 16777287: return Key_F24;
case 16777288: return Key_F25;
case 16777289: return Key_F26;
case 16777290: return Key_F27;
case 16777291: return Key_F28;
case 16777292: return Key_F29;
case 16777293: return Key_F30;
case 16777294: return Key_F31;
case 16777295: return Key_F32;
case 16777296: return Key_F33;
case 16777297: return Key_F34;
case 16777298: return Key_F35;
case 16777299: return Key_Super_L;
case 16777300: return Key_Super_R;
case 16777301: return Key_Menu;
case 16777302: return Key_Hyper_L;
case 16777303: return Key_Hyper_R;
case 16777304: return Key_Help;
case 16777305: return Key_Direction_L;
case 16777312: return Key_Direction_R;
case 16781571: return Key_AltGr;
case 16781600: return Key_Multi_key;
case 16781623: return Key_Codeinput;
case 16781628: return Key_SingleCandidate;
case 16781629: return Key_MultipleCandidate;
case 16781630: return Key_PreviousCandidate;
case 16781694: return Key_Mode_switch;
case 16781601: return Key_Kanji;
case 16781602: return Key_Muhenkan;
case 16781603: return Key_Henkan;
case 16781604: return Key_Romaji;
case 16781605: return Key_Hiragana;
case 16781606: return Key_Katakana;
case 16781607: return Key_Hiragana_Katakana;
case 16781608: return Key_Zenkaku;
case 16781609: return Key_Hankaku;
case 16781610: return Key_Zenkaku_Hankaku;
case 16781611: return Key_Touroku;
case 16781612: return Key_Massyo;
case 16781613: return Key_Kana_Lock;
case 16781614: return Key_Kana_Shift;
case 16781615: return Key_Eisu_Shift;
case 16781616: return Key_Eisu_toggle;
case 16781617: return Key_Hangul;
case 16781618: return Key_Hangul_Start;
case 16781619: return Key_Hangul_End;
case 16781620: return Key_Hangul_Hanja;
case 16781621: return Key_Hangul_Jamo;
case 16781622: return Key_Hangul_Romaja;
case 16781624: return Key_Hangul_Jeonja;
case 16781625: return Key_Hangul_Banja;
case 16781626: return Key_Hangul_PreHanja;
case 16781627: return Key_Hangul_PostHanja;
case 16781631: return Key_Hangul_Special;
case 16781904: return Key_Dead_Grave;
case 16781905: return Key_Dead_Acute;
case 16781906: return Key_Dead_Circumflex;
case 16781907: return Key_Dead_Tilde;
case 16781908: return Key_Dead_Macron;
case 16781909: return Key_Dead_Breve;
case 16781910: return Key_Dead_Abovedot;
case 16781911: return Key_Dead_Diaeresis;
case 16781912: return Key_Dead_Abovering;
case 16781913: return Key_Dead_Doubleacute;
case 16781914: return Key_Dead_Caron;
case 16781915: return Key_Dead_Cedilla;
case 16781916: return Key_Dead_Ogonek;
case 16781917: return Key_Dead_Iota;
case 16781918: return Key_Dead_Voiced_Sound;
case 16781919: return Key_Dead_Semivoiced_Sound;
case 16781920: return Key_Dead_Belowdot;
case 16781921: return Key_Dead_Hook;
case 16781922: return Key_Dead_Horn;
case 16781923: return Key_Dead_Stroke;
case 16781924: return Key_Dead_Abovecomma;
case 16781925: return Key_Dead_Abovereversedcomma;
case 16781926: return Key_Dead_Doublegrave;
case 16781927: return Key_Dead_Belowring;
case 16781928: return Key_Dead_Belowmacron;
case 16781929: return Key_Dead_Belowcircumflex;
case 16781930: return Key_Dead_Belowtilde;
case 16781931: return Key_Dead_Belowbreve;
case 16781932: return Key_Dead_Belowdiaeresis;
case 16781933: return Key_Dead_Invertedbreve;
case 16781934: return Key_Dead_Belowcomma;
case 16781935: return Key_Dead_Currency;
case 16781952: return Key_Dead_a;
case 16781953: return Key_Dead_A;
case 16781954: return Key_Dead_e;
case 16781955: return Key_Dead_E;
case 16781956: return Key_Dead_i;
case 16781957: return Key_Dead_I;
case 16781958: return Key_Dead_o;
case 16781959: return Key_Dead_O;
case 16781960: return Key_Dead_u;
case 16781961: return Key_Dead_U;
case 16781962: return Key_Dead_Small_Schwa;
case 16781963: return Key_Dead_Capital_Schwa;
case 16781964: return Key_Dead_Greek;
case 16781968: return Key_Dead_Lowline;
case 16781969: return Key_Dead_Aboveverticalline;
case 16781970: return Key_Dead_Belowverticalline;
case 16781971: return Key_Dead_Longsolidusoverlay;
case 16777313: return Key_Back;
case 16777314: return Key_Forward;
case 16777315: return Key_Stop;
case 16777316: return Key_Refresh;
case 16777328: return Key_VolumeDown;
case 16777329: return Key_VolumeMute;
case 16777330: return Key_VolumeUp;
case 16777331: return Key_BassBoost;
case 16777332: return Key_BassUp;
case 16777333: return Key_BassDown;
case 16777334: return Key_TrebleUp;
case 16777335: return Key_TrebleDown;
case 16777344: return Key_MediaPlay;
case 16777345: return Key_MediaStop;
case 16777346: return Key_MediaPrevious;
case 16777347: return Key_MediaNext;
case 16777348: return Key_MediaRecord;
case 16777349: return Key_MediaPause;
case 16777350: return Key_MediaTogglePlayPause;
case 16777360: return Key_HomePage;
case 16777361: return Key_Favorites;
case 16777362: return Key_Search;
case 16777363: return Key_Standby;
case 16777364: return Key_OpenUrl;
case 16777376: return Key_LaunchMail;
case 16777377: return Key_LaunchMedia;
case 16777378: return Key_Launch0;
case 16777379: return Key_Launch1;
case 16777380: return Key_Launch2;
case 16777381: return Key_Launch3;
case 16777382: return Key_Launch4;
case 16777383: return Key_Launch5;
case 16777384: return Key_Launch6;
case 16777385: return Key_Launch7;
case 16777386: return Key_Launch8;
case 16777387: return Key_Launch9;
case 16777388: return Key_LaunchA;
case 16777389: return Key_LaunchB;
case 16777390: return Key_LaunchC;
case 16777391: return Key_LaunchD;
case 16777392: return Key_LaunchE;
case 16777393: return Key_LaunchF;
case 16777394: return Key_MonBrightnessUp;
case 16777395: return Key_MonBrightnessDown;
case 16777396: return Key_KeyboardLightOnOff;
case 16777397: return Key_KeyboardBrightnessUp;
case 16777398: return Key_KeyboardBrightnessDown;
case 16777399: return Key_PowerOff;
case 16777400: return Key_WakeUp;
case 16777401: return Key_Eject;
case 16777402: return Key_ScreenSaver;
case 16777403: return Key_WWW;
case 16777404: return Key_Memo;
case 16777405: return Key_LightBulb;
case 16777406: return Key_Shop;
case 16777407: return Key_History;
case 16777408: return Key_AddFavorite;
case 16777409: return Key_HotLinks;
case 16777410: return Key_BrightnessAdjust;
case 16777411: return Key_Finance;
case 16777412: return Key_Community;
case 16777413: return Key_AudioRewind;
case 16777414: return Key_BackForward;
case 16777415: return Key_ApplicationLeft;
case 16777416: return Key_ApplicationRight;
case 16777417: return Key_Book;
case 16777418: return Key_CD;
case 16777419: return Key_Calculator;
case 16777420: return Key_ToDoList;
case 16777421: return Key_ClearGrab;
case 16777422: return Key_Close;
case 16777423: return Key_Copy;
case 16777424: return Key_Cut;
case 16777425: return Key_Display;
case 16777426: return Key_DOS;
case 16777427: return Key_Documents;
case 16777428: return Key_Excel;
case 16777429: return Key_Explorer;
case 16777430: return Key_Game;
case 16777431: return Key_Go;
case 16777432: return Key_iTouch;
case 16777433: return Key_LogOff;
case 16777434: return Key_Market;
case 16777435: return Key_Meeting;
case 16777436: return Key_MenuKB;
case 16777437: return Key_MenuPB;
case 16777438: return Key_MySites;
case 16777439: return Key_News;
case 16777440: return Key_OfficeHome;
case 16777441: return Key_Option;
case 16777442: return Key_Paste;
case 16777443: return Key_Phone;
case 16777444: return Key_Calendar;
case 16777445: return Key_Reply;
case 16777446: return Key_Reload;
case 16777447: return Key_RotateWindows;
case 16777448: return Key_RotationPB;
case 16777449: return Key_RotationKB;
case 16777450: return Key_Save;
case 16777451: return Key_Send;
case 16777452: return Key_Spell;
case 16777453: return Key_SplitScreen;
case 16777454: return Key_Support;
case 16777455: return Key_TaskPane;
case 16777456: return Key_Terminal;
case 16777457: return Key_Tools;
case 16777458: return Key_Travel;
case 16777459: return Key_Video;
case 16777460: return Key_Word;
case 16777461: return Key_Xfer;
case 16777462: return Key_ZoomIn;
case 16777463: return Key_ZoomOut;
case 16777464: return Key_Away;
case 16777465: return Key_Messenger;
case 16777466: return Key_WebCam;
case 16777467: return Key_MailForward;
case 16777468: return Key_Pictures;
case 16777469: return Key_Music;
case 16777470: return Key_Battery;
case 16777471: return Key_Bluetooth;
case 16777472: return Key_WLAN;
case 16777473: return Key_UWB;
case 16777474: return Key_AudioForward;
case 16777475: return Key_AudioRepeat;
case 16777476: return Key_AudioRandomPlay;
case 16777477: return Key_Subtitle;
case 16777478: return Key_AudioCycleTrack;
case 16777479: return Key_Time;
case 16777480: return Key_Hibernate;
case 16777481: return Key_View;
case 16777482: return Key_TopMenu;
case 16777483: return Key_PowerDown;
case 16777484: return Key_Suspend;
case 16777485: return Key_ContrastAdjust;
case 16777486: return Key_LaunchG;
case 16777487: return Key_LaunchH;
case 16777488: return Key_TouchpadToggle;
case 16777489: return Key_TouchpadOn;
case 16777490: return Key_TouchpadOff;
case 16777491: return Key_MicMute;
case 16777492: return Key_Red;
case 16777493: return Key_Green;
case 16777494: return Key_Yellow;
case 16777495: return Key_Blue;
case 16777496: return Key_ChannelUp;
case 16777497: return Key_ChannelDown;
case 16777498: return Key_Guide;
case 16777499: return Key_Info;
case 16777500: return Key_Settings;
case 16777501: return Key_MicVolumeUp;
case 16777502: return Key_MicVolumeDown;
case 16777504: return Key_New;
case 16777505: return Key_Open;
case 16777506: return Key_Find;
case 16777507: return Key_Undo;
case 16777508: return Key_Redo;
case 16842751: return Key_MediaLast;
case 16842752: return Key_Select;
case 16842753: return Key_Yes;
case 16842754: return Key_No;
case 16908289: return Key_Cancel;
case 16908290: return Key_Printer;
case 16908291: return Key_Execute;
case 16908292: return Key_Sleep;
case 16908293: return Key_Play;
case 16908294: return Key_Zoom;
case 16908298: return Key_Exit;
case 17825792: return Key_Context1;
case 17825793: return Key_Context2;
case 17825794: return Key_Context3;
case 17825795: return Key_Context4;
case 17825796: return Key_Call;
case 17825797: return Key_Hangup;
case 17825798: return Key_Flip;
case 17825799: return Key_ToggleCallHangup;
case 17825800: return Key_VoiceDial;
case 17825801: return Key_LastNumberRedial;
case 17825824: return Key_Camera;
case 17825825: return Key_CameraFocus;
case 33554431: return Key_unknown;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::KeyboardModifier
*
* @see KeyboardModifiers
*/
public enum KeyboardModifier implements QtFlagEnumerator {
/**
* Representing Qt::
*/
NoModifier(0),
/**
* Representing Qt::
*/
ShiftModifier(33554432),
/**
* Representing Qt::
*/
ControlModifier(67108864),
/**
* Representing Qt::
*/
AltModifier(134217728),
/**
* Representing Qt::
*/
MetaModifier(268435456),
/**
* Representing Qt::
*/
KeypadModifier(536870912),
/**
* Representing Qt::
*/
GroupSwitchModifier(1073741824),
/**
* Representing Qt::
*/
KeyboardModifierMask(-33554432);
static {
QtJambi_LibraryUtilities.initialize();
}
private KeyboardModifier(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull KeyboardModifiers asFlags() {
return new KeyboardModifiers(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull KeyboardModifiers combined(@NonNull KeyboardModifier e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull KeyboardModifiers cleared(@NonNull KeyboardModifier e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link KeyboardModifiers} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull KeyboardModifiers flags(@Nullable KeyboardModifier @NonNull... values) {
return new KeyboardModifiers(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull KeyboardModifier resolve(int value) {
switch (value) {
case 0: return NoModifier;
case 33554432: return ShiftModifier;
case 67108864: return ControlModifier;
case 134217728: return AltModifier;
case 268435456: return MetaModifier;
case 536870912: return KeypadModifier;
case 1073741824: return GroupSwitchModifier;
case -33554432: return KeyboardModifierMask;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link KeyboardModifier}
*/
public static final class KeyboardModifiers extends QFlags implements Comparable {
private static final long serialVersionUID = 0x1e5b543af4a5c2cL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new KeyboardModifiers where the flags in args are set.
* @param args enum entries
*/
public KeyboardModifiers(@Nullable KeyboardModifier @NonNull... args){
super(args);
}
/**
* Creates a new KeyboardModifiers with given value.
* @param value
*/
public KeyboardModifiers(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new KeyboardModifiers
*/
@Override
public final @NonNull KeyboardModifiers combined(@StrictNonNull KeyboardModifier e){
return new KeyboardModifiers(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull KeyboardModifiers setFlag(@Nullable KeyboardModifier e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull KeyboardModifiers setFlag(@Nullable KeyboardModifier e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this KeyboardModifiers.
* @return array of enum entries
*/
@Override
public final @NonNull KeyboardModifier @NonNull[] flags(){
return super.flags(KeyboardModifier.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull KeyboardModifiers clone(){
return new KeyboardModifiers(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull KeyboardModifiers other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::LayoutDirection
*/
public enum LayoutDirection implements QtEnumerator {
/**
* Representing Qt::
*/
LeftToRight(0),
/**
* Representing Qt::
*/
RightToLeft(1),
/**
* Representing Qt::
*/
LayoutDirectionAuto(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private LayoutDirection(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull LayoutDirection resolve(int value) {
switch (value) {
case 0: return LeftToRight;
case 1: return RightToLeft;
case 2: return LayoutDirectionAuto;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::MaskMode
*/
public enum MaskMode implements QtEnumerator {
/**
* Representing Qt::
*/
MaskInColor(0),
/**
* Representing Qt::
*/
MaskOutColor(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private MaskMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull MaskMode resolve(int value) {
switch (value) {
case 0: return MaskInColor;
case 1: return MaskOutColor;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::MatchFlag
*
* @see MatchFlags
*/
public enum MatchFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
MatchExactly(0),
/**
* Representing Qt::
*/
MatchContains(1),
/**
* Representing Qt::
*/
MatchStartsWith(2),
/**
* Representing Qt::
*/
MatchEndsWith(3),
/**
* Representing Qt::
*/
MatchRegularExpression(4),
/**
* Representing Qt::
*/
MatchWildcard(5),
/**
* Representing Qt::
*/
MatchFixedString(8),
/**
* Representing Qt::
*/
MatchTypeMask(15),
/**
* Representing Qt::
*/
MatchCaseSensitive(16),
/**
* Representing Qt::
*/
MatchWrap(32),
/**
* Representing Qt::
*/
MatchRecursive(64);
static {
QtJambi_LibraryUtilities.initialize();
}
private MatchFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull MatchFlags asFlags() {
return new MatchFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MatchFlags combined(@NonNull MatchFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MatchFlags cleared(@NonNull MatchFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link MatchFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull MatchFlags flags(@Nullable MatchFlag @NonNull... values) {
return new MatchFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull MatchFlag resolve(int value) {
switch (value) {
case 0: return MatchExactly;
case 1: return MatchContains;
case 2: return MatchStartsWith;
case 3: return MatchEndsWith;
case 4: return MatchRegularExpression;
case 5: return MatchWildcard;
case 8: return MatchFixedString;
case 15: return MatchTypeMask;
case 16: return MatchCaseSensitive;
case 32: return MatchWrap;
case 64: return MatchRecursive;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link MatchFlag}
*/
public static final class MatchFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0xe52b74c57cb33994L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new MatchFlags where the flags in args are set.
* @param args enum entries
*/
public MatchFlags(@Nullable MatchFlag @NonNull... args){
super(args);
}
/**
* Creates a new MatchFlags with given value.
* @param value
*/
public MatchFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new MatchFlags
*/
@Override
public final @NonNull MatchFlags combined(@StrictNonNull MatchFlag e){
return new MatchFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull MatchFlags setFlag(@Nullable MatchFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull MatchFlags setFlag(@Nullable MatchFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this MatchFlags.
* @return array of enum entries
*/
@Override
public final @NonNull MatchFlag @NonNull[] flags(){
return super.flags(MatchFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull MatchFlags clone(){
return new MatchFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull MatchFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::MouseButton
*
* @see MouseButtons
*/
@QtRejectedEntries({"BackButton", "XButton1", "ForwardButton", "XButton2", "TaskButton", "MaxMouseButton"})
public enum MouseButton implements QtFlagEnumerator {
/**
* Representing Qt::
*/
NoButton(0),
/**
* Representing Qt::
*/
LeftButton(1),
/**
* Representing Qt::
*/
RightButton(2),
/**
* Representing Qt::
*/
MiddleButton(4),
/**
* Representing Qt::
*/
BackButton(8),
/**
* Representing Qt::
*/
XButton1(8),
/**
* Representing Qt::
*/
ExtraButton1(8),
/**
* Representing Qt::
*/
ForwardButton(16),
/**
* Representing Qt::
*/
XButton2(16),
/**
* Representing Qt::
*/
ExtraButton2(16),
/**
* Representing Qt::
*/
TaskButton(32),
/**
* Representing Qt::
*/
ExtraButton3(32),
/**
* Representing Qt::
*/
ExtraButton4(64),
/**
* Representing Qt::
*/
ExtraButton5(128),
/**
* Representing Qt::
*/
ExtraButton6(256),
/**
* Representing Qt::
*/
ExtraButton7(512),
/**
* Representing Qt::
*/
ExtraButton8(1024),
/**
* Representing Qt::
*/
ExtraButton9(2048),
/**
* Representing Qt::
*/
ExtraButton10(4096),
/**
* Representing Qt::
*/
ExtraButton11(8192),
/**
* Representing Qt::
*/
ExtraButton12(16384),
/**
* Representing Qt::
*/
ExtraButton13(32768),
/**
* Representing Qt::
*/
ExtraButton14(65536),
/**
* Representing Qt::
*/
ExtraButton15(131072),
/**
* Representing Qt::
*/
ExtraButton16(262144),
/**
* Representing Qt::
*/
ExtraButton17(524288),
/**
* Representing Qt::
*/
ExtraButton18(1048576),
/**
* Representing Qt::
*/
ExtraButton19(2097152),
/**
* Representing Qt::
*/
ExtraButton20(4194304),
/**
* Representing Qt::
*/
ExtraButton21(8388608),
/**
* Representing Qt::
*/
ExtraButton22(16777216),
/**
* Representing Qt::
*/
ExtraButton23(33554432),
/**
* Representing Qt::
*/
ExtraButton24(67108864),
/**
* Representing Qt::
*/
AllButtons(134217727),
/**
* Representing Qt::
*/
MaxMouseButton(67108864),
/**
* Representing Qt::
*/
MouseButtonMask(-1);
static {
QtJambi_LibraryUtilities.initialize();
}
private MouseButton(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull MouseButtons asFlags() {
return new MouseButtons(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MouseButtons combined(@NonNull MouseButton e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MouseButtons cleared(@NonNull MouseButton e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link MouseButtons} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull MouseButtons flags(@Nullable MouseButton @NonNull... values) {
return new MouseButtons(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull MouseButton resolve(int value) {
switch (value) {
case 0: return NoButton;
case 1: return LeftButton;
case 2: return RightButton;
case 4: return MiddleButton;
case 8: return ExtraButton1;
case 16: return ExtraButton2;
case 32: return ExtraButton3;
case 64: return ExtraButton4;
case 128: return ExtraButton5;
case 256: return ExtraButton6;
case 512: return ExtraButton7;
case 1024: return ExtraButton8;
case 2048: return ExtraButton9;
case 4096: return ExtraButton10;
case 8192: return ExtraButton11;
case 16384: return ExtraButton12;
case 32768: return ExtraButton13;
case 65536: return ExtraButton14;
case 131072: return ExtraButton15;
case 262144: return ExtraButton16;
case 524288: return ExtraButton17;
case 1048576: return ExtraButton18;
case 2097152: return ExtraButton19;
case 4194304: return ExtraButton20;
case 8388608: return ExtraButton21;
case 16777216: return ExtraButton22;
case 33554432: return ExtraButton23;
case 67108864: return ExtraButton24;
case 134217727: return AllButtons;
case -1: return MouseButtonMask;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link MouseButton}
*/
public static final class MouseButtons extends QFlags implements Comparable {
private static final long serialVersionUID = 0xd0ea232122520ba8L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new MouseButtons where the flags in args are set.
* @param args enum entries
*/
public MouseButtons(@Nullable MouseButton @NonNull... args){
super(args);
}
/**
* Creates a new MouseButtons with given value.
* @param value
*/
public MouseButtons(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new MouseButtons
*/
@Override
public final @NonNull MouseButtons combined(@StrictNonNull MouseButton e){
return new MouseButtons(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull MouseButtons setFlag(@Nullable MouseButton e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull MouseButtons setFlag(@Nullable MouseButton e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this MouseButtons.
* @return array of enum entries
*/
@Override
public final @NonNull MouseButton @NonNull[] flags(){
return super.flags(MouseButton.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull MouseButtons clone(){
return new MouseButtons(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull MouseButtons other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::MouseEventFlag
*
* @see MouseEventFlags
*/
public enum MouseEventFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
NoMouseEventFlag(0),
/**
* Representing Qt::
*/
MouseEventCreatedDoubleClick(1),
/**
* Representing Qt::
*/
MouseEventFlagMask(255);
static {
QtJambi_LibraryUtilities.initialize();
}
private MouseEventFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull MouseEventFlags asFlags() {
return new MouseEventFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MouseEventFlags combined(@NonNull MouseEventFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull MouseEventFlags cleared(@NonNull MouseEventFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link MouseEventFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull MouseEventFlags flags(@Nullable MouseEventFlag @NonNull... values) {
return new MouseEventFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull MouseEventFlag resolve(int value) {
switch (value) {
case 0: return NoMouseEventFlag;
case 1: return MouseEventCreatedDoubleClick;
case 255: return MouseEventFlagMask;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link MouseEventFlag}
*/
public static final class MouseEventFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0x16a152411e32883fL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new MouseEventFlags where the flags in args are set.
* @param args enum entries
*/
public MouseEventFlags(@Nullable MouseEventFlag @NonNull... args){
super(args);
}
/**
* Creates a new MouseEventFlags with given value.
* @param value
*/
public MouseEventFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new MouseEventFlags
*/
@Override
public final @NonNull MouseEventFlags combined(@StrictNonNull MouseEventFlag e){
return new MouseEventFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull MouseEventFlags setFlag(@Nullable MouseEventFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull MouseEventFlags setFlag(@Nullable MouseEventFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this MouseEventFlags.
* @return array of enum entries
*/
@Override
public final @NonNull MouseEventFlag @NonNull[] flags(){
return super.flags(MouseEventFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull MouseEventFlags clone(){
return new MouseEventFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull MouseEventFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::MouseEventSource
*/
public enum MouseEventSource implements QtEnumerator {
/**
* Representing Qt::
*/
MouseEventNotSynthesized(0),
/**
* Representing Qt::
*/
MouseEventSynthesizedBySystem(1),
/**
* Representing Qt::
*/
MouseEventSynthesizedByQt(2),
/**
* Representing Qt::
*/
MouseEventSynthesizedByApplication(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private MouseEventSource(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull MouseEventSource resolve(int value) {
switch (value) {
case 0: return MouseEventNotSynthesized;
case 1: return MouseEventSynthesizedBySystem;
case 2: return MouseEventSynthesizedByQt;
case 3: return MouseEventSynthesizedByApplication;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::NativeGestureType
*/
public enum NativeGestureType implements QtEnumerator {
/**
* Representing Qt::
*/
BeginNativeGesture(0),
/**
* Representing Qt::
*/
EndNativeGesture(1),
/**
* Representing Qt::
*/
PanNativeGesture(2),
/**
* Representing Qt::
*/
ZoomNativeGesture(3),
/**
* Representing Qt::
*/
SmartZoomNativeGesture(4),
/**
* Representing Qt::
*/
RotateNativeGesture(5),
/**
* Representing Qt::
*/
SwipeNativeGesture(6);
static {
QtJambi_LibraryUtilities.initialize();
}
private NativeGestureType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull NativeGestureType resolve(int value) {
switch (value) {
case 0: return BeginNativeGesture;
case 1: return EndNativeGesture;
case 2: return PanNativeGesture;
case 3: return ZoomNativeGesture;
case 4: return SmartZoomNativeGesture;
case 5: return RotateNativeGesture;
case 6: return SwipeNativeGesture;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::NavigationMode
*/
@QtUnlistedEnum
public enum NavigationMode implements QtEnumerator {
/**
* Representing Qt::
*/
NavigationModeNone(0),
/**
* Representing Qt::
*/
NavigationModeKeypadTabOrder(1),
/**
* Representing Qt::
*/
NavigationModeKeypadDirectional(2),
/**
* Representing Qt::
*/
NavigationModeCursorAuto(3),
/**
* Representing Qt::
*/
NavigationModeCursorForceVisible(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private NavigationMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull NavigationMode resolve(int value) {
switch (value) {
case 0: return NavigationModeNone;
case 1: return NavigationModeKeypadTabOrder;
case 2: return NavigationModeKeypadDirectional;
case 3: return NavigationModeCursorAuto;
case 4: return NavigationModeCursorForceVisible;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::Orientation
*
* @see Orientations
*/
public enum Orientation implements QtFlagEnumerator {
/**
* Representing Qt::
*/
Horizontal(1),
/**
* Representing Qt::
*/
Vertical(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private Orientation(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull Orientations asFlags() {
return new Orientations(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Orientations combined(@NonNull Orientation e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull Orientations cleared(@NonNull Orientation e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link Orientations} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull Orientations flags(@Nullable Orientation @NonNull... values) {
return new Orientations(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull Orientation resolve(int value) {
switch (value) {
case 1: return Horizontal;
case 2: return Vertical;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link Orientation}
*/
public static final class Orientations extends QFlags implements Comparable {
private static final long serialVersionUID = 0x86e5ea6bbe4bd92fL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new Orientations where the flags in args are set.
* @param args enum entries
*/
public Orientations(@Nullable Orientation @NonNull... args){
super(args);
}
/**
* Creates a new Orientations with given value.
* @param value
*/
public Orientations(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new Orientations
*/
@Override
public final @NonNull Orientations combined(@StrictNonNull Orientation e){
return new Orientations(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull Orientations setFlag(@Nullable Orientation e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull Orientations setFlag(@Nullable Orientation e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this Orientations.
* @return array of enum entries
*/
@Override
public final @NonNull Orientation @NonNull[] flags(){
return super.flags(Orientation.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull Orientations clone(){
return new Orientations(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull Orientations other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::PenCapStyle
*/
public enum PenCapStyle implements QtEnumerator {
/**
* Representing Qt::
*/
FlatCap(0),
/**
* Representing Qt::
*/
SquareCap(16),
/**
* Representing Qt::
*/
RoundCap(32),
/**
* Representing Qt::
*/
MPenCapStyle(48);
static {
QtJambi_LibraryUtilities.initialize();
}
private PenCapStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull PenCapStyle resolve(int value) {
switch (value) {
case 0: return FlatCap;
case 16: return SquareCap;
case 32: return RoundCap;
case 48: return MPenCapStyle;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::PenJoinStyle
*/
public enum PenJoinStyle implements QtEnumerator {
/**
* Representing Qt::
*/
MiterJoin(0),
/**
* Representing Qt::
*/
BevelJoin(64),
/**
* Representing Qt::
*/
RoundJoin(128),
/**
* Representing Qt::
*/
SvgMiterJoin(256),
/**
* Representing Qt::
*/
MPenJoinStyle(448);
static {
QtJambi_LibraryUtilities.initialize();
}
private PenJoinStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull PenJoinStyle resolve(int value) {
switch (value) {
case 0: return MiterJoin;
case 64: return BevelJoin;
case 128: return RoundJoin;
case 256: return SvgMiterJoin;
case 448: return MPenJoinStyle;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::PenStyle
*/
public enum PenStyle implements QtEnumerator {
/**
* Representing Qt::
*/
NoPen(0),
/**
* Representing Qt::
*/
SolidLine(1),
/**
* Representing Qt::
*/
DashLine(2),
/**
* Representing Qt::
*/
DotLine(3),
/**
* Representing Qt::
*/
DashDotLine(4),
/**
* Representing Qt::
*/
DashDotDotLine(5),
/**
* Representing Qt::
*/
CustomDashLine(6),
/**
* Representing Qt::
*/
MPenStyle(15);
static {
QtJambi_LibraryUtilities.initialize();
}
private PenStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull PenStyle resolve(int value) {
switch (value) {
case 0: return NoPen;
case 1: return SolidLine;
case 2: return DashLine;
case 3: return DotLine;
case 4: return DashDotLine;
case 5: return DashDotDotLine;
case 6: return CustomDashLine;
case 15: return MPenStyle;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::PermissionStatus
*/
public enum PermissionStatus implements QtEnumerator {
/**
* Representing Qt::
*/
Undetermined(0),
/**
* Representing Qt::
*/
Granted(1),
/**
* Representing Qt::
*/
Denied(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private PermissionStatus(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull PermissionStatus resolve(int value) {
switch (value) {
case 0: return Undetermined;
case 1: return Granted;
case 2: return Denied;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ScreenOrientation
*
* @see ScreenOrientations
*/
public enum ScreenOrientation implements QtFlagEnumerator {
/**
* Representing Qt::
*/
PrimaryOrientation(0),
/**
* Representing Qt::
*/
PortraitOrientation(1),
/**
* Representing Qt::
*/
LandscapeOrientation(2),
/**
* Representing Qt::
*/
InvertedPortraitOrientation(4),
/**
* Representing Qt::
*/
InvertedLandscapeOrientation(8);
static {
QtJambi_LibraryUtilities.initialize();
}
private ScreenOrientation(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull ScreenOrientations asFlags() {
return new ScreenOrientations(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ScreenOrientations combined(@NonNull ScreenOrientation e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ScreenOrientations cleared(@NonNull ScreenOrientation e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link ScreenOrientations} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull ScreenOrientations flags(@Nullable ScreenOrientation @NonNull... values) {
return new ScreenOrientations(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ScreenOrientation resolve(int value) {
switch (value) {
case 0: return PrimaryOrientation;
case 1: return PortraitOrientation;
case 2: return LandscapeOrientation;
case 4: return InvertedPortraitOrientation;
case 8: return InvertedLandscapeOrientation;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link ScreenOrientation}
*/
public static final class ScreenOrientations extends QFlags implements Comparable {
private static final long serialVersionUID = 0x9f66ee8fc16dc747L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new ScreenOrientations where the flags in args are set.
* @param args enum entries
*/
public ScreenOrientations(@Nullable ScreenOrientation @NonNull... args){
super(args);
}
/**
* Creates a new ScreenOrientations with given value.
* @param value
*/
public ScreenOrientations(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new ScreenOrientations
*/
@Override
public final @NonNull ScreenOrientations combined(@StrictNonNull ScreenOrientation e){
return new ScreenOrientations(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull ScreenOrientations setFlag(@Nullable ScreenOrientation e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull ScreenOrientations setFlag(@Nullable ScreenOrientation e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this ScreenOrientations.
* @return array of enum entries
*/
@Override
public final @NonNull ScreenOrientation @NonNull[] flags(){
return super.flags(ScreenOrientation.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull ScreenOrientations clone(){
return new ScreenOrientations(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull ScreenOrientations other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::ScrollBarPolicy
*/
public enum ScrollBarPolicy implements QtEnumerator {
/**
* Representing Qt::
*/
ScrollBarAsNeeded(0),
/**
* Representing Qt::
*/
ScrollBarAlwaysOff(1),
/**
* Representing Qt::
*/
ScrollBarAlwaysOn(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private ScrollBarPolicy(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ScrollBarPolicy resolve(int value) {
switch (value) {
case 0: return ScrollBarAsNeeded;
case 1: return ScrollBarAlwaysOff;
case 2: return ScrollBarAlwaysOn;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ScrollPhase
*/
public enum ScrollPhase implements QtEnumerator {
/**
* Representing Qt::
*/
NoScrollPhase(0),
/**
* Representing Qt::
*/
ScrollBegin(1),
/**
* Representing Qt::
*/
ScrollUpdate(2),
/**
* Representing Qt::
*/
ScrollEnd(3),
/**
* Representing Qt::
*/
ScrollMomentum(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ScrollPhase(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ScrollPhase resolve(int value) {
switch (value) {
case 0: return NoScrollPhase;
case 1: return ScrollBegin;
case 2: return ScrollUpdate;
case 3: return ScrollEnd;
case 4: return ScrollMomentum;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ShortcutContext
*/
public enum ShortcutContext implements QtEnumerator {
/**
* Representing Qt::
*/
WidgetShortcut(0),
/**
* Representing Qt::
*/
WindowShortcut(1),
/**
* Representing Qt::
*/
ApplicationShortcut(2),
/**
* Representing Qt::
*/
WidgetWithChildrenShortcut(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private ShortcutContext(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ShortcutContext resolve(int value) {
switch (value) {
case 0: return WidgetShortcut;
case 1: return WindowShortcut;
case 2: return ApplicationShortcut;
case 3: return WidgetWithChildrenShortcut;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::SizeHint
*/
public enum SizeHint implements QtEnumerator {
/**
* Representing Qt::
*/
MinimumSize(0),
/**
* Representing Qt::
*/
PreferredSize(1),
/**
* Representing Qt::
*/
MaximumSize(2),
/**
* Representing Qt::
*/
MinimumDescent(3),
/**
* Representing Qt::
*/
NSizeHints(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private SizeHint(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull SizeHint resolve(int value) {
switch (value) {
case 0: return MinimumSize;
case 1: return PreferredSize;
case 2: return MaximumSize;
case 3: return MinimumDescent;
case 4: return NSizeHints;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::SizeMode
*/
public enum SizeMode implements QtEnumerator {
/**
* Representing Qt::
*/
AbsoluteSize(0),
/**
* Representing Qt::
*/
RelativeSize(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private SizeMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull SizeMode resolve(int value) {
switch (value) {
case 0: return AbsoluteSize;
case 1: return RelativeSize;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::SortOrder
*/
public enum SortOrder implements QtEnumerator {
/**
* Representing Qt::
*/
AscendingOrder(0),
/**
* Representing Qt::
*/
DescendingOrder(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private SortOrder(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull SortOrder resolve(int value) {
switch (value) {
case 0: return AscendingOrder;
case 1: return DescendingOrder;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::SplitBehaviorFlags
*
* @see SplitBehavior
*/
public enum SplitBehaviorFlags implements QtFlagEnumerator {
/**
* Representing Qt::
*/
KeepEmptyParts(0),
/**
* Representing Qt::
*/
SkipEmptyParts(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private SplitBehaviorFlags(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull SplitBehavior asFlags() {
return new SplitBehavior(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull SplitBehavior combined(@NonNull SplitBehaviorFlags e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull SplitBehavior cleared(@NonNull SplitBehaviorFlags e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link SplitBehavior} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull SplitBehavior flags(@Nullable SplitBehaviorFlags @NonNull... values) {
return new SplitBehavior(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull SplitBehaviorFlags resolve(int value) {
switch (value) {
case 0: return KeepEmptyParts;
case 1: return SkipEmptyParts;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link SplitBehaviorFlags}
*/
public static final class SplitBehavior extends QFlags implements Comparable {
private static final long serialVersionUID = 0x7383c0ed51069a39L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new SplitBehavior where the flags in args are set.
* @param args enum entries
*/
public SplitBehavior(@Nullable SplitBehaviorFlags @NonNull... args){
super(args);
}
/**
* Creates a new SplitBehavior with given value.
* @param value
*/
public SplitBehavior(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new SplitBehavior
*/
@Override
public final @NonNull SplitBehavior combined(@StrictNonNull SplitBehaviorFlags e){
return new SplitBehavior(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull SplitBehavior setFlag(@Nullable SplitBehaviorFlags e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull SplitBehavior setFlag(@Nullable SplitBehaviorFlags e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this SplitBehavior.
* @return array of enum entries
*/
@Override
public final @NonNull SplitBehaviorFlags @NonNull[] flags(){
return super.flags(SplitBehaviorFlags.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull SplitBehavior clone(){
return new SplitBehavior(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull SplitBehavior other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::TabFocusBehavior
*/
public enum TabFocusBehavior implements QtEnumerator {
/**
* Representing Qt::
*/
NoTabFocus(0),
/**
* Representing Qt::
*/
TabFocusTextControls(1),
/**
* Representing Qt::
*/
TabFocusListControls(2),
/**
* Representing Qt::
*/
TabFocusAllControls(255);
static {
QtJambi_LibraryUtilities.initialize();
}
private TabFocusBehavior(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TabFocusBehavior resolve(int value) {
switch (value) {
case 0: return NoTabFocus;
case 1: return TabFocusTextControls;
case 2: return TabFocusListControls;
case 255: return TabFocusAllControls;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TextElideMode
*/
public enum TextElideMode implements QtEnumerator {
/**
* Representing Qt::
*/
ElideLeft(0),
/**
* Representing Qt::
*/
ElideRight(1),
/**
* Representing Qt::
*/
ElideMiddle(2),
/**
* Representing Qt::
*/
ElideNone(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private TextElideMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TextElideMode resolve(int value) {
switch (value) {
case 0: return ElideLeft;
case 1: return ElideRight;
case 2: return ElideMiddle;
case 3: return ElideNone;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TextFlag
*/
public enum TextFlag implements QtEnumerator {
/**
* Representing Qt::
*/
TextSingleLine(256),
/**
* Representing Qt::
*/
TextDontClip(512),
/**
* Representing Qt::
*/
TextExpandTabs(1024),
/**
* Representing Qt::
*/
TextShowMnemonic(2048),
/**
* Representing Qt::
*/
TextWordWrap(4096),
/**
* Representing Qt::
*/
TextWrapAnywhere(8192),
/**
* Representing Qt::
*/
TextDontPrint(16384),
/**
* Representing Qt::
*/
TextIncludeTrailingSpaces(134217728),
/**
* Representing Qt::
*/
TextHideMnemonic(32768),
/**
* Representing Qt::
*/
TextJustificationForced(65536),
/**
* Representing Qt::
*/
TextForceLeftToRight(131072),
/**
* Representing Qt::
*/
TextForceRightToLeft(262144),
/**
* Representing Qt::
*/
TextLongestVariant(524288);
static {
QtJambi_LibraryUtilities.initialize();
}
private TextFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TextFlag resolve(int value) {
switch (value) {
case 256: return TextSingleLine;
case 512: return TextDontClip;
case 1024: return TextExpandTabs;
case 2048: return TextShowMnemonic;
case 4096: return TextWordWrap;
case 8192: return TextWrapAnywhere;
case 16384: return TextDontPrint;
case 134217728: return TextIncludeTrailingSpaces;
case 32768: return TextHideMnemonic;
case 65536: return TextJustificationForced;
case 131072: return TextForceLeftToRight;
case 262144: return TextForceRightToLeft;
case 524288: return TextLongestVariant;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TextFormat
*/
public enum TextFormat implements QtEnumerator {
/**
* Representing Qt::
*/
PlainText(0),
/**
* Representing Qt::
*/
RichText(1),
/**
* Representing Qt::
*/
AutoText(2),
/**
* Representing Qt::
*/
MarkdownText(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private TextFormat(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TextFormat resolve(int value) {
switch (value) {
case 0: return PlainText;
case 1: return RichText;
case 2: return AutoText;
case 3: return MarkdownText;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TextInteractionFlag
*
* @see TextInteractionFlags
*/
public enum TextInteractionFlag implements QtFlagEnumerator {
/**
* Representing Qt::
*/
NoTextInteraction(0),
/**
* Representing Qt::
*/
TextSelectableByMouse(1),
/**
* Representing Qt::
*/
TextSelectableByKeyboard(2),
/**
* Representing Qt::
*/
LinksAccessibleByMouse(4),
/**
* Representing Qt::
*/
LinksAccessibleByKeyboard(8),
/**
* Representing Qt::
*/
TextEditable(16),
/**
* Representing Qt::
*/
TextEditorInteraction(19),
/**
* Representing Qt::
*/
TextBrowserInteraction(13);
static {
QtJambi_LibraryUtilities.initialize();
}
private TextInteractionFlag(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull TextInteractionFlags asFlags() {
return new TextInteractionFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull TextInteractionFlags combined(@NonNull TextInteractionFlag e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull TextInteractionFlags cleared(@NonNull TextInteractionFlag e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link TextInteractionFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull TextInteractionFlags flags(@Nullable TextInteractionFlag @NonNull... values) {
return new TextInteractionFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TextInteractionFlag resolve(int value) {
switch (value) {
case 0: return NoTextInteraction;
case 1: return TextSelectableByMouse;
case 2: return TextSelectableByKeyboard;
case 4: return LinksAccessibleByMouse;
case 8: return LinksAccessibleByKeyboard;
case 16: return TextEditable;
case 19: return TextEditorInteraction;
case 13: return TextBrowserInteraction;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link TextInteractionFlag}
*/
public static final class TextInteractionFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0xd88b7287f6140537L;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new TextInteractionFlags where the flags in args are set.
* @param args enum entries
*/
public TextInteractionFlags(@Nullable TextInteractionFlag @NonNull... args){
super(args);
}
/**
* Creates a new TextInteractionFlags with given value.
* @param value
*/
public TextInteractionFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new TextInteractionFlags
*/
@Override
public final @NonNull TextInteractionFlags combined(@StrictNonNull TextInteractionFlag e){
return new TextInteractionFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull TextInteractionFlags setFlag(@Nullable TextInteractionFlag e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull TextInteractionFlags setFlag(@Nullable TextInteractionFlag e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this TextInteractionFlags.
* @return array of enum entries
*/
@Override
public final @NonNull TextInteractionFlag @NonNull[] flags(){
return super.flags(TextInteractionFlag.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull TextInteractionFlags clone(){
return new TextInteractionFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull TextInteractionFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::TileRule
*/
@QtUnlistedEnum
public enum TileRule implements QtEnumerator {
/**
* Representing Qt::
*/
StretchTile(0),
/**
* Representing Qt::
*/
RepeatTile(1),
/**
* Representing Qt::
*/
RoundTile(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private TileRule(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TileRule resolve(int value) {
switch (value) {
case 0: return StretchTile;
case 1: return RepeatTile;
case 2: return RoundTile;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TimeSpec
*/
public enum TimeSpec implements QtEnumerator {
/**
* Representing Qt::
*/
LocalTime(0),
/**
* Representing Qt::
*/
UTC(1),
/**
* Representing Qt::
*/
OffsetFromUTC(2),
/**
* Representing Qt::
*/
TimeZone(3);
static {
QtJambi_LibraryUtilities.initialize();
}
private TimeSpec(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TimeSpec resolve(int value) {
switch (value) {
case 0: return LocalTime;
case 1: return UTC;
case 2: return OffsetFromUTC;
case 3: return TimeZone;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TimerType
*/
public enum TimerType implements QtEnumerator {
/**
* Representing Qt::
*/
PreciseTimer(0),
/**
* Representing Qt::
*/
CoarseTimer(1),
/**
* Representing Qt::
*/
VeryCoarseTimer(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private TimerType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TimerType resolve(int value) {
switch (value) {
case 0: return PreciseTimer;
case 1: return CoarseTimer;
case 2: return VeryCoarseTimer;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ToolBarArea
*
* @see ToolBarAreas
*/
@QtRejectedEntries({"AllToolBarAreas"})
public enum ToolBarArea implements QtFlagEnumerator {
/**
* Representing Qt::
*/
LeftToolBarArea(1),
/**
* Representing Qt::
*/
RightToolBarArea(2),
/**
* Representing Qt::
*/
TopToolBarArea(4),
/**
* Representing Qt::
*/
BottomToolBarArea(8),
/**
* Representing Qt::
*/
ToolBarArea_Mask(15),
/**
* Representing Qt::
*/
AllToolBarAreas(15),
/**
* Representing Qt::
*/
NoToolBarArea(0);
static {
QtJambi_LibraryUtilities.initialize();
}
private ToolBarArea(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull ToolBarAreas asFlags() {
return new ToolBarAreas(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ToolBarAreas combined(@NonNull ToolBarArea e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull ToolBarAreas cleared(@NonNull ToolBarArea e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link ToolBarAreas} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull ToolBarAreas flags(@Nullable ToolBarArea @NonNull... values) {
return new ToolBarAreas(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ToolBarArea resolve(int value) {
switch (value) {
case 1: return LeftToolBarArea;
case 2: return RightToolBarArea;
case 4: return TopToolBarArea;
case 8: return BottomToolBarArea;
case 15: return ToolBarArea_Mask;
case 0: return NoToolBarArea;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link ToolBarArea}
*/
public static final class ToolBarAreas extends QFlags implements Comparable {
private static final long serialVersionUID = 0x8a1d8360260b7e0fL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new ToolBarAreas where the flags in args are set.
* @param args enum entries
*/
public ToolBarAreas(@Nullable ToolBarArea @NonNull... args){
super(args);
}
/**
* Creates a new ToolBarAreas with given value.
* @param value
*/
public ToolBarAreas(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new ToolBarAreas
*/
@Override
public final @NonNull ToolBarAreas combined(@StrictNonNull ToolBarArea e){
return new ToolBarAreas(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull ToolBarAreas setFlag(@Nullable ToolBarArea e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull ToolBarAreas setFlag(@Nullable ToolBarArea e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this ToolBarAreas.
* @return array of enum entries
*/
@Override
public final @NonNull ToolBarArea @NonNull[] flags(){
return super.flags(ToolBarArea.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull ToolBarAreas clone(){
return new ToolBarAreas(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull ToolBarAreas other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::ToolBarAreaSizes
*/
@QtUnlistedEnum
public enum ToolBarAreaSizes implements QtEnumerator {
/**
* Representing Qt::
*/
NToolBarAreas(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ToolBarAreaSizes(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ToolBarAreaSizes resolve(int value) {
switch (value) {
case 4: return NToolBarAreas;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::ToolButtonStyle
*/
public enum ToolButtonStyle implements QtEnumerator {
/**
* Representing Qt::
*/
ToolButtonIconOnly(0),
/**
* Representing Qt::
*/
ToolButtonTextOnly(1),
/**
* Representing Qt::
*/
ToolButtonTextBesideIcon(2),
/**
* Representing Qt::
*/
ToolButtonTextUnderIcon(3),
/**
* Representing Qt::
*/
ToolButtonFollowStyle(4);
static {
QtJambi_LibraryUtilities.initialize();
}
private ToolButtonStyle(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull ToolButtonStyle resolve(int value) {
switch (value) {
case 0: return ToolButtonIconOnly;
case 1: return ToolButtonTextOnly;
case 2: return ToolButtonTextBesideIcon;
case 3: return ToolButtonTextUnderIcon;
case 4: return ToolButtonFollowStyle;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::TouchPointState
*
* @see TouchPointStates
*/
public enum TouchPointState implements QtFlagEnumerator {
/**
* Representing Qt::
*/
TouchPointUnknownState(0),
/**
* Representing Qt::
*/
TouchPointPressed(1),
/**
* Representing Qt::
*/
TouchPointMoved(2),
/**
* Representing Qt::
*/
TouchPointStationary(4),
/**
* Representing Qt::
*/
TouchPointReleased(8);
static {
QtJambi_LibraryUtilities.initialize();
}
private TouchPointState(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull TouchPointStates asFlags() {
return new TouchPointStates(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull TouchPointStates combined(@NonNull TouchPointState e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull TouchPointStates cleared(@NonNull TouchPointState e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link TouchPointStates} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull TouchPointStates flags(@Nullable TouchPointState @NonNull... values) {
return new TouchPointStates(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TouchPointState resolve(int value) {
switch (value) {
case 0: return TouchPointUnknownState;
case 1: return TouchPointPressed;
case 2: return TouchPointMoved;
case 4: return TouchPointStationary;
case 8: return TouchPointReleased;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link TouchPointState}
*/
public static final class TouchPointStates extends QFlags implements Comparable {
private static final long serialVersionUID = 0xf76302d6bf84f56dL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new TouchPointStates where the flags in args are set.
* @param args enum entries
*/
public TouchPointStates(@Nullable TouchPointState @NonNull... args){
super(args);
}
/**
* Creates a new TouchPointStates with given value.
* @param value
*/
public TouchPointStates(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new TouchPointStates
*/
@Override
public final @NonNull TouchPointStates combined(@StrictNonNull TouchPointState e){
return new TouchPointStates(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull TouchPointStates setFlag(@Nullable TouchPointState e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull TouchPointStates setFlag(@Nullable TouchPointState e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this TouchPointStates.
* @return array of enum entries
*/
@Override
public final @NonNull TouchPointState @NonNull[] flags(){
return super.flags(TouchPointState.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull TouchPointStates clone(){
return new TouchPointStates(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull TouchPointStates other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::TransformationMode
*/
public enum TransformationMode implements QtEnumerator {
/**
* Representing Qt::
*/
FastTransformation(0),
/**
* Representing Qt::
*/
SmoothTransformation(1);
static {
QtJambi_LibraryUtilities.initialize();
}
private TransformationMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull TransformationMode resolve(int value) {
switch (value) {
case 0: return FastTransformation;
case 1: return SmoothTransformation;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::UIEffect
*/
@QtUnlistedEnum
public enum UIEffect implements QtEnumerator {
/**
* Representing Qt::
*/
UI_General(0),
/**
* Representing Qt::
*/
UI_AnimateMenu(1),
/**
* Representing Qt::
*/
UI_FadeMenu(2),
/**
* Representing Qt::
*/
UI_AnimateCombo(3),
/**
* Representing Qt::
*/
UI_AnimateTooltip(4),
/**
* Representing Qt::
*/
UI_FadeTooltip(5),
/**
* Representing Qt::
*/
UI_AnimateToolBox(6);
static {
QtJambi_LibraryUtilities.initialize();
}
private UIEffect(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull UIEffect resolve(int value) {
switch (value) {
case 0: return UI_General;
case 1: return UI_AnimateMenu;
case 2: return UI_FadeMenu;
case 3: return UI_AnimateCombo;
case 4: return UI_AnimateTooltip;
case 5: return UI_FadeTooltip;
case 6: return UI_AnimateToolBox;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::WhiteSpaceMode
*/
@QtUnlistedEnum
public enum WhiteSpaceMode implements QtEnumerator {
/**
* Representing Qt::
*/
WhiteSpaceNormal(0),
/**
* Representing Qt::
*/
WhiteSpacePre(1),
/**
* Representing Qt::
*/
WhiteSpaceNoWrap(2),
/**
* Representing Qt::
*/
WhiteSpaceModeUndefined(-1);
static {
QtJambi_LibraryUtilities.initialize();
}
private WhiteSpaceMode(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WhiteSpaceMode resolve(int value) {
switch (value) {
case 0: return WhiteSpaceNormal;
case 1: return WhiteSpacePre;
case 2: return WhiteSpaceNoWrap;
case -1: return WhiteSpaceModeUndefined;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::WidgetAttribute
*/
public enum WidgetAttribute implements QtEnumerator {
/**
* Representing Qt::
*/
WA_Disabled(0),
/**
* Representing Qt::
*/
WA_UnderMouse(1),
/**
* Representing Qt::
*/
WA_MouseTracking(2),
/**
* Representing Qt::
*/
WA_OpaquePaintEvent(4),
/**
* Representing Qt::
*/
WA_StaticContents(5),
/**
* Representing Qt::
*/
WA_LaidOut(7),
/**
* Representing Qt::
*/
WA_PaintOnScreen(8),
/**
* Representing Qt::
*/
WA_NoSystemBackground(9),
/**
* Representing Qt::
*/
WA_UpdatesDisabled(10),
/**
* Representing Qt::
*/
WA_Mapped(11),
/**
* Representing Qt::
*/
WA_InputMethodEnabled(14),
/**
* Representing Qt::
*/
WA_WState_Visible(15),
/**
* Representing Qt::
*/
WA_WState_Hidden(16),
/**
* Representing Qt::
*/
WA_ForceDisabled(32),
/**
* Representing Qt::
*/
WA_KeyCompression(33),
/**
* Representing Qt::
*/
WA_PendingMoveEvent(34),
/**
* Representing Qt::
*/
WA_PendingResizeEvent(35),
/**
* Representing Qt::
*/
WA_SetPalette(36),
/**
* Representing Qt::
*/
WA_SetFont(37),
/**
* Representing Qt::
*/
WA_SetCursor(38),
/**
* Representing Qt::
*/
WA_NoChildEventsFromChildren(39),
/**
* Representing Qt::
*/
WA_WindowModified(41),
/**
* Representing Qt::
*/
WA_Resized(42),
/**
* Representing Qt::
*/
WA_Moved(43),
/**
* Representing Qt::
*/
WA_PendingUpdate(44),
/**
* Representing Qt::
*/
WA_InvalidSize(45),
/**
* Representing Qt::
*/
WA_CustomWhatsThis(47),
/**
* Representing Qt::
*/
WA_LayoutOnEntireRect(48),
/**
* Representing Qt::
*/
WA_OutsideWSRange(49),
/**
* Representing Qt::
*/
WA_GrabbedShortcut(50),
/**
* Representing Qt::
*/
WA_TransparentForMouseEvents(51),
/**
* Representing Qt::
*/
WA_PaintUnclipped(52),
/**
* Representing Qt::
*/
WA_SetWindowIcon(53),
/**
* Representing Qt::
*/
WA_NoMouseReplay(54),
/**
* Representing Qt::
*/
WA_DeleteOnClose(55),
/**
* Representing Qt::
*/
WA_RightToLeft(56),
/**
* Representing Qt::
*/
WA_SetLayoutDirection(57),
/**
* Representing Qt::
*/
WA_NoChildEventsForParent(58),
/**
* Representing Qt::
*/
WA_ForceUpdatesDisabled(59),
/**
* Representing Qt::
*/
WA_WState_Created(60),
/**
* Representing Qt::
*/
WA_WState_CompressKeys(61),
/**
* Representing Qt::
*/
WA_WState_InPaintEvent(62),
/**
* Representing Qt::
*/
WA_WState_Reparented(63),
/**
* Representing Qt::
*/
WA_WState_ConfigPending(64),
/**
* Representing Qt::
*/
WA_WState_Polished(66),
/**
* Representing Qt::
*/
WA_WState_OwnSizePolicy(68),
/**
* Representing Qt::
*/
WA_WState_ExplicitShowHide(69),
/**
* Representing Qt::
*/
WA_ShowModal(70),
/**
* Representing Qt::
*/
WA_MouseNoMask(71),
/**
* Representing Qt::
*/
WA_NoMousePropagation(73),
/**
* Representing Qt::
*/
WA_Hover(74),
/**
* Representing Qt::
*/
WA_InputMethodTransparent(75),
/**
* Representing Qt::
*/
WA_QuitOnClose(76),
/**
* Representing Qt::
*/
WA_KeyboardFocusChange(77),
/**
* Representing Qt::
*/
WA_AcceptDrops(78),
/**
* Representing Qt::
*/
WA_DropSiteRegistered(79),
/**
* Representing Qt::
*/
WA_WindowPropagation(80),
/**
* Representing Qt::
*/
WA_NoX11EventCompression(81),
/**
* Representing Qt::
*/
WA_TintedBackground(82),
/**
* Representing Qt::
*/
WA_X11OpenGLOverlay(83),
/**
* Representing Qt::
*/
WA_AlwaysShowToolTips(84),
/**
* Representing Qt::
*/
WA_MacOpaqueSizeGrip(85),
/**
* Representing Qt::
*/
WA_SetStyle(86),
/**
* Representing Qt::
*/
WA_SetLocale(87),
/**
* Representing Qt::
*/
WA_MacShowFocusRect(88),
/**
* Representing Qt::
*/
WA_MacNormalSize(89),
/**
* Representing Qt::
*/
WA_MacSmallSize(90),
/**
* Representing Qt::
*/
WA_MacMiniSize(91),
/**
* Representing Qt::
*/
WA_LayoutUsesWidgetRect(92),
/**
* Representing Qt::
*/
WA_StyledBackground(93),
/**
* Representing Qt::
*/
WA_CanHostQMdiSubWindowTitleBar(95),
/**
* Representing Qt::
*/
WA_MacAlwaysShowToolWindow(96),
/**
* Representing Qt::
*/
WA_StyleSheet(97),
/**
* Representing Qt::
*/
WA_ShowWithoutActivating(98),
/**
* Representing Qt::
*/
WA_X11BypassTransientForHint(99),
/**
* Representing Qt::
*/
WA_NativeWindow(100),
/**
* Representing Qt::
*/
WA_DontCreateNativeAncestors(101),
/**
* Representing Qt::
*/
WA_DontShowOnScreen(103),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeDesktop(104),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeDock(105),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeToolBar(106),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeMenu(107),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeUtility(108),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeSplash(109),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeDialog(110),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeDropDownMenu(111),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypePopupMenu(112),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeToolTip(113),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeNotification(114),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeCombo(115),
/**
* Representing Qt::
*/
WA_X11NetWmWindowTypeDND(116),
/**
* Representing Qt::
*/
WA_SetWindowModality(118),
/**
* Representing Qt::
*/
WA_WState_WindowOpacitySet(119),
/**
* Representing Qt::
*/
WA_TranslucentBackground(120),
/**
* Representing Qt::
*/
WA_AcceptTouchEvents(121),
/**
* Representing Qt::
*/
WA_WState_AcceptedTouchBeginEvent(122),
/**
* Representing Qt::
*/
WA_TouchPadAcceptSingleTouchEvents(123),
/**
* Representing Qt::
*/
WA_X11DoNotAcceptFocus(126),
/**
* Representing Qt::
*/
WA_AlwaysStackOnTop(128),
/**
* Representing Qt::
*/
WA_TabletTracking(129),
/**
* Representing Qt::
*/
WA_ContentsMarginsRespectsSafeArea(130),
/**
* Representing Qt::
*/
WA_StyleSheetTarget(131),
/**
* Representing Qt::
*/
WA_AttributeCount(132);
static {
QtJambi_LibraryUtilities.initialize();
}
private WidgetAttribute(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WidgetAttribute resolve(int value) {
switch (value) {
case 0: return WA_Disabled;
case 1: return WA_UnderMouse;
case 2: return WA_MouseTracking;
case 4: return WA_OpaquePaintEvent;
case 5: return WA_StaticContents;
case 7: return WA_LaidOut;
case 8: return WA_PaintOnScreen;
case 9: return WA_NoSystemBackground;
case 10: return WA_UpdatesDisabled;
case 11: return WA_Mapped;
case 14: return WA_InputMethodEnabled;
case 15: return WA_WState_Visible;
case 16: return WA_WState_Hidden;
case 32: return WA_ForceDisabled;
case 33: return WA_KeyCompression;
case 34: return WA_PendingMoveEvent;
case 35: return WA_PendingResizeEvent;
case 36: return WA_SetPalette;
case 37: return WA_SetFont;
case 38: return WA_SetCursor;
case 39: return WA_NoChildEventsFromChildren;
case 41: return WA_WindowModified;
case 42: return WA_Resized;
case 43: return WA_Moved;
case 44: return WA_PendingUpdate;
case 45: return WA_InvalidSize;
case 47: return WA_CustomWhatsThis;
case 48: return WA_LayoutOnEntireRect;
case 49: return WA_OutsideWSRange;
case 50: return WA_GrabbedShortcut;
case 51: return WA_TransparentForMouseEvents;
case 52: return WA_PaintUnclipped;
case 53: return WA_SetWindowIcon;
case 54: return WA_NoMouseReplay;
case 55: return WA_DeleteOnClose;
case 56: return WA_RightToLeft;
case 57: return WA_SetLayoutDirection;
case 58: return WA_NoChildEventsForParent;
case 59: return WA_ForceUpdatesDisabled;
case 60: return WA_WState_Created;
case 61: return WA_WState_CompressKeys;
case 62: return WA_WState_InPaintEvent;
case 63: return WA_WState_Reparented;
case 64: return WA_WState_ConfigPending;
case 66: return WA_WState_Polished;
case 68: return WA_WState_OwnSizePolicy;
case 69: return WA_WState_ExplicitShowHide;
case 70: return WA_ShowModal;
case 71: return WA_MouseNoMask;
case 73: return WA_NoMousePropagation;
case 74: return WA_Hover;
case 75: return WA_InputMethodTransparent;
case 76: return WA_QuitOnClose;
case 77: return WA_KeyboardFocusChange;
case 78: return WA_AcceptDrops;
case 79: return WA_DropSiteRegistered;
case 80: return WA_WindowPropagation;
case 81: return WA_NoX11EventCompression;
case 82: return WA_TintedBackground;
case 83: return WA_X11OpenGLOverlay;
case 84: return WA_AlwaysShowToolTips;
case 85: return WA_MacOpaqueSizeGrip;
case 86: return WA_SetStyle;
case 87: return WA_SetLocale;
case 88: return WA_MacShowFocusRect;
case 89: return WA_MacNormalSize;
case 90: return WA_MacSmallSize;
case 91: return WA_MacMiniSize;
case 92: return WA_LayoutUsesWidgetRect;
case 93: return WA_StyledBackground;
case 95: return WA_CanHostQMdiSubWindowTitleBar;
case 96: return WA_MacAlwaysShowToolWindow;
case 97: return WA_StyleSheet;
case 98: return WA_ShowWithoutActivating;
case 99: return WA_X11BypassTransientForHint;
case 100: return WA_NativeWindow;
case 101: return WA_DontCreateNativeAncestors;
case 103: return WA_DontShowOnScreen;
case 104: return WA_X11NetWmWindowTypeDesktop;
case 105: return WA_X11NetWmWindowTypeDock;
case 106: return WA_X11NetWmWindowTypeToolBar;
case 107: return WA_X11NetWmWindowTypeMenu;
case 108: return WA_X11NetWmWindowTypeUtility;
case 109: return WA_X11NetWmWindowTypeSplash;
case 110: return WA_X11NetWmWindowTypeDialog;
case 111: return WA_X11NetWmWindowTypeDropDownMenu;
case 112: return WA_X11NetWmWindowTypePopupMenu;
case 113: return WA_X11NetWmWindowTypeToolTip;
case 114: return WA_X11NetWmWindowTypeNotification;
case 115: return WA_X11NetWmWindowTypeCombo;
case 116: return WA_X11NetWmWindowTypeDND;
case 118: return WA_SetWindowModality;
case 119: return WA_WState_WindowOpacitySet;
case 120: return WA_TranslucentBackground;
case 121: return WA_AcceptTouchEvents;
case 122: return WA_WState_AcceptedTouchBeginEvent;
case 123: return WA_TouchPadAcceptSingleTouchEvents;
case 126: return WA_X11DoNotAcceptFocus;
case 128: return WA_AlwaysStackOnTop;
case 129: return WA_TabletTracking;
case 130: return WA_ContentsMarginsRespectsSafeArea;
case 131: return WA_StyleSheetTarget;
case 132: return WA_AttributeCount;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::WindowFrameSection
*/
@QtUnlistedEnum
public enum WindowFrameSection implements QtEnumerator {
/**
* Representing Qt::
*/
NoSection(0),
/**
* Representing Qt::
*/
LeftSection(1),
/**
* Representing Qt::
*/
TopLeftSection(2),
/**
* Representing Qt::
*/
TopSection(3),
/**
* Representing Qt::
*/
TopRightSection(4),
/**
* Representing Qt::
*/
RightSection(5),
/**
* Representing Qt::
*/
BottomRightSection(6),
/**
* Representing Qt::
*/
BottomSection(7),
/**
* Representing Qt::
*/
BottomLeftSection(8),
/**
* Representing Qt::
*/
TitleBarArea(9);
static {
QtJambi_LibraryUtilities.initialize();
}
private WindowFrameSection(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WindowFrameSection resolve(int value) {
switch (value) {
case 0: return NoSection;
case 1: return LeftSection;
case 2: return TopLeftSection;
case 3: return TopSection;
case 4: return TopRightSection;
case 5: return RightSection;
case 6: return BottomRightSection;
case 7: return BottomSection;
case 8: return BottomLeftSection;
case 9: return TitleBarArea;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::WindowModality
*/
public enum WindowModality implements QtEnumerator {
/**
* Representing Qt::
*/
NonModal(0),
/**
* Representing Qt::
*/
WindowModal(1),
/**
* Representing Qt::
*/
ApplicationModal(2);
static {
QtJambi_LibraryUtilities.initialize();
}
private WindowModality(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WindowModality resolve(int value) {
switch (value) {
case 0: return NonModal;
case 1: return WindowModal;
case 2: return ApplicationModal;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* Java wrapper for Qt enum Qt::WindowState
*
* @see WindowStates
*/
public enum WindowState implements QtFlagEnumerator {
/**
* Representing Qt::
*/
WindowNoState(0),
/**
* Representing Qt::
*/
WindowMinimized(1),
/**
* Representing Qt::
*/
WindowMaximized(2),
/**
* Representing Qt::
*/
WindowFullScreen(4),
/**
* Representing Qt::
*/
WindowActive(8);
static {
QtJambi_LibraryUtilities.initialize();
}
private WindowState(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull WindowStates asFlags() {
return new WindowStates(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull WindowStates combined(@NonNull WindowState e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull WindowStates cleared(@NonNull WindowState e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link WindowStates} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull WindowStates flags(@Nullable WindowState @NonNull... values) {
return new WindowStates(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WindowState resolve(int value) {
switch (value) {
case 0: return WindowNoState;
case 1: return WindowMinimized;
case 2: return WindowMaximized;
case 4: return WindowFullScreen;
case 8: return WindowActive;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link WindowState}
*/
public static final class WindowStates extends QFlags implements Comparable {
private static final long serialVersionUID = 0x47389fc27c17f83cL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new WindowStates where the flags in args are set.
* @param args enum entries
*/
public WindowStates(@Nullable WindowState @NonNull... args){
super(args);
}
/**
* Creates a new WindowStates with given value.
* @param value
*/
public WindowStates(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new WindowStates
*/
@Override
public final @NonNull WindowStates combined(@StrictNonNull WindowState e){
return new WindowStates(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull WindowStates setFlag(@Nullable WindowState e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull WindowStates setFlag(@Nullable WindowState e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this WindowStates.
* @return array of enum entries
*/
@Override
public final @NonNull WindowState @NonNull[] flags(){
return super.flags(WindowState.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull WindowStates clone(){
return new WindowStates(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull WindowStates other){
return Integer.compare(value(), other.value());
}
}
/**
* Java wrapper for Qt enum Qt::WindowType
*
* @see WindowFlags
*/
@QtRejectedEntries({"X11BypassWindowManagerHint"})
public enum WindowType implements QtFlagEnumerator {
/**
* Representing Qt::
*/
Widget(0),
/**
* Representing Qt::
*/
Window(1),
/**
* Representing Qt::
*/
Dialog(3),
/**
* Representing Qt::
*/
Sheet(5),
/**
* Representing Qt::
*/
Drawer(7),
/**
* Representing Qt::
*/
Popup(9),
/**
* Representing Qt::
*/
Tool(11),
/**
* Representing Qt::
*/
ToolTip(13),
/**
* Representing Qt::
*/
SplashScreen(15),
/**
* Representing Qt::
*/
Desktop(17),
/**
* Representing Qt::
*/
SubWindow(18),
/**
* Representing Qt::
*/
ForeignWindow(33),
/**
* Representing Qt::
*/
CoverWindow(65),
/**
* Representing Qt::
*/
WindowType_Mask(255),
/**
* Representing Qt::
*/
MSWindowsFixedSizeDialogHint(256),
/**
* Representing Qt::
*/
MSWindowsOwnDC(512),
/**
* Representing Qt::
*/
BypassWindowManagerHint(1024),
/**
* Representing Qt::
*/
X11BypassWindowManagerHint(1024),
/**
* Representing Qt::
*/
FramelessWindowHint(2048),
/**
* Representing Qt::
*/
WindowTitleHint(4096),
/**
* Representing Qt::
*/
WindowSystemMenuHint(8192),
/**
* Representing Qt::
*/
WindowMinimizeButtonHint(16384),
/**
* Representing Qt::
*/
WindowMaximizeButtonHint(32768),
/**
* Representing Qt::
*/
WindowMinMaxButtonsHint(49152),
/**
* Representing Qt::
*/
WindowContextHelpButtonHint(65536),
/**
* Representing Qt::
*/
WindowShadeButtonHint(131072),
/**
* Representing Qt::
*/
WindowStaysOnTopHint(262144),
/**
* Representing Qt::
*/
WindowTransparentForInput(524288),
/**
* Representing Qt::
*/
WindowOverridesSystemGestures(1048576),
/**
* Representing Qt::
*/
WindowDoesNotAcceptFocus(2097152),
/**
* Representing Qt::
*/
MaximizeUsingFullscreenGeometryHint(4194304),
/**
* Representing Qt::
*/
CustomizeWindowHint(33554432),
/**
* Representing Qt::
*/
WindowStaysOnBottomHint(67108864),
/**
* Representing Qt::
*/
WindowCloseButtonHint(134217728),
/**
* Representing Qt::
*/
MacWindowToolBarButtonHint(268435456),
/**
* Representing Qt::
*/
BypassGraphicsProxyWidget(536870912),
/**
* Representing Qt::
*/
NoDropShadowWindowHint(1073741824),
/**
* Representing Qt::
*/
WindowFullscreenButtonHint(-2147483648);
static {
QtJambi_LibraryUtilities.initialize();
}
private WindowType(int value) {
this.value = value;
}
/**
* {@inheritDoc}
*/
public int value() {
return value;
}
/**
* Create a QFlags of the enum entry.
* @return QFlags
*/
public @NonNull WindowFlags asFlags() {
return new WindowFlags(value);
}
/**
* Combines this entry with other enum entry.
* @param e enum entry
* @return new flag
*/
public @NonNull WindowFlags combined(@NonNull WindowType e) {
return asFlags().setFlag(e, true);
}
/**
* Excludes other enum entry from a flag of this entry.
* @param e enum entry
* @return new flag
*/
public @NonNull WindowFlags cleared(@NonNull WindowType e) {
return asFlags().setFlag(e, false);
}
/**
* Creates a new {@link WindowFlags} from the entries.
* @param values entries
* @return new flag
*/
public static @NonNull WindowFlags flags(@Nullable WindowType @NonNull... values) {
return new WindowFlags(values);
}
/**
* Returns the corresponding enum entry for the given value.
* @param value
* @return enum entry
*/
public static @NonNull WindowType resolve(int value) {
switch (value) {
case 0: return Widget;
case 1: return Window;
case 3: return Dialog;
case 5: return Sheet;
case 7: return Drawer;
case 9: return Popup;
case 11: return Tool;
case 13: return ToolTip;
case 15: return SplashScreen;
case 17: return Desktop;
case 18: return SubWindow;
case 33: return ForeignWindow;
case 65: return CoverWindow;
case 255: return WindowType_Mask;
case 256: return MSWindowsFixedSizeDialogHint;
case 512: return MSWindowsOwnDC;
case 1024: return BypassWindowManagerHint;
case 2048: return FramelessWindowHint;
case 4096: return WindowTitleHint;
case 8192: return WindowSystemMenuHint;
case 16384: return WindowMinimizeButtonHint;
case 32768: return WindowMaximizeButtonHint;
case 49152: return WindowMinMaxButtonsHint;
case 65536: return WindowContextHelpButtonHint;
case 131072: return WindowShadeButtonHint;
case 262144: return WindowStaysOnTopHint;
case 524288: return WindowTransparentForInput;
case 1048576: return WindowOverridesSystemGestures;
case 2097152: return WindowDoesNotAcceptFocus;
case 4194304: return MaximizeUsingFullscreenGeometryHint;
case 33554432: return CustomizeWindowHint;
case 67108864: return WindowStaysOnBottomHint;
case 134217728: return WindowCloseButtonHint;
case 268435456: return MacWindowToolBarButtonHint;
case 536870912: return BypassGraphicsProxyWidget;
case 1073741824: return NoDropShadowWindowHint;
case -2147483648: return WindowFullscreenButtonHint;
default: throw new QNoSuchEnumValueException(value);
}
}
private final int value;
}
/**
* {@link QFlags} type for enum {@link WindowType}
*/
public static final class WindowFlags extends QFlags implements Comparable {
private static final long serialVersionUID = 0x4b60224f25ec75acL;
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Creates a new WindowFlags where the flags in args are set.
* @param args enum entries
*/
public WindowFlags(@Nullable WindowType @NonNull... args){
super(args);
}
/**
* Creates a new WindowFlags with given value.
* @param value
*/
public WindowFlags(int value) {
super(value);
}
/**
* Combines this flags with enum entry.
* @param e enum entry
* @return new WindowFlags
*/
@Override
public final @NonNull WindowFlags combined(@StrictNonNull WindowType e){
return new WindowFlags(value() | e.value());
}
/**
* Sets the flag e
* @param e enum entry
* @return this
*/
public final @NonNull WindowFlags setFlag(@Nullable WindowType e){
return setFlag(e, true);
}
/**
* Sets or clears the flag flag
* @param e enum entry
* @param on set (true) or clear (false)
* @return this
*/
public final @NonNull WindowFlags setFlag(@Nullable WindowType e, boolean on){
if (on) {
setValue(value() | e.value());
}else {
setValue(value() & ~e.value());
}
return this;
}
/**
* Returns an array of flag objects represented by this WindowFlags.
* @return array of enum entries
*/
@Override
public final @NonNull WindowType @NonNull[] flags(){
return super.flags(WindowType.values());
}
/**
* {@inheritDoc}
*/
@Override
public final @NonNull WindowFlags clone(){
return new WindowFlags(value());
}
/**
* {@inheritDoc}
*/
@Override
public final int compareTo(@StrictNonNull WindowFlags other){
return Integer.compare(value(), other.value());
}
}
/**
* Qt::partial_ordering represents the result of a comparison that allows for unordered results
* Java wrapper for Qt class Qt::partial_ordering
*/
public static final class partial_ordering extends QtObject
{
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Constructor for internal use only.
* @param p expected to be null.
* @hidden
*/
@NativeAccess
protected partial_ordering(QPrivateConstructor p) { super(p); }
/**
* See partial_ordering::equivalent
*/
public static final int equivalent = 0;
/**
*
*/
public static final int greater = 1;
/**
*
*/
public static final int less = -1;
/**
* See partial_ordering::unordered
*/
public static final int unordered = unordered();
private static native int unordered();
}
/**
* Qt::weak_ordering represents a comparison where equivalent values are still distinguishable
* Java wrapper for Qt class Qt::weak_ordering
*/
public static final class weak_ordering extends QtObject
{
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Constructor for internal use only.
* @param p expected to be null.
* @hidden
*/
@NativeAccess
protected weak_ordering(QPrivateConstructor p) { super(p); }
/**
*
*/
public static final int equivalent = 0;
/**
*
*/
public static final int greater = 1;
/**
*
*/
public static final int less = -1;
}
/**
* Qt::strong_ordering represents a comparison where equivalent values are indistinguishable
* Java wrapper for Qt class Qt::strong_ordering
*/
public static final class strong_ordering extends QtObject
{
static {
QtJambi_LibraryUtilities.initialize();
}
/**
* Constructor for internal use only.
* @param p expected to be null.
* @hidden
*/
@NativeAccess
protected strong_ordering(QPrivateConstructor p) { super(p); }
/**
* See strong_ordering::equivalent
*/
public static final int equivalent = 0;
/**
*
*/
public static final int equal = 0;
/**
*
*/
public static final int greater = 1;
/**
*
*/
public static final int less = -1;
}
/**
* See Qt::
*/
public native static void beginPropertyUpdateGroup();
/**
* See Qt::
*/
public native static void endPropertyUpdateGroup();
/**
* See qGlobalQHashSeed()
*/
public native static int qGlobalQHashSeed();
/**
* See qSetGlobalQHashSeed(int)
*/
public native static void qSetGlobalQHashSeed(int newSeed);
public final static @NonNull QMetaObject staticMetaObject = QMetaObject.forType(Qt.class);
}