diff options
Diffstat (limited to 'old/qtbindings/com_nokia_qt_core/qtscript_Qt.cpp')
| -rw-r--r-- | old/qtbindings/com_nokia_qt_core/qtscript_Qt.cpp | 7259 |
1 files changed, 7259 insertions, 0 deletions
diff --git a/old/qtbindings/com_nokia_qt_core/qtscript_Qt.cpp b/old/qtbindings/com_nokia_qt_core/qtscript_Qt.cpp new file mode 100644 index 0000000..5be9246 --- /dev/null +++ b/old/qtbindings/com_nokia_qt_core/qtscript_Qt.cpp @@ -0,0 +1,7259 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of QtUiTest. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include <QtScript/QScriptEngine> +#include <QtScript/QScriptContext> +#include <QtScript/QScriptValue> +#include <QtCore/QStringList> +#include <QtCore/QDebug> +#include <qmetaobject.h> + +#include <qnamespace.h> +#include <QTextDocument> +#include <QVariant> + +static const char * const qtscript_Qt_function_names[] = { + "Qt" + // static + // prototype + , "toString" +}; + +static const char * const qtscript_Qt_function_signatures[] = { + "" + // static + // prototype +"" +}; + +static QScriptValue qtscript_Qt_throw_ambiguity_error_helper( + QScriptContext *context, const char *functionName, const char *signatures) +{ + QStringList lines = QString::fromLatin1(signatures).split(QLatin1Char('\n')); + QStringList fullSignatures; + for (int i = 0; i < lines.size(); ++i) + fullSignatures.append(QString::fromLatin1("%0(%1)").arg(functionName).arg(lines.at(i))); + return context->throwError(QString::fromLatin1("Qt::%0(): could not find a function match; candidates are:\n%1") + .arg(functionName).arg(fullSignatures.join(QLatin1String("\n")))); +} + +struct qtscript_Qt_metaObject_helper : private QObject +{ + static const QMetaObject *get() + { return &static_cast<qtscript_Qt_metaObject_helper*>(0)->staticQtMetaObject; } +}; + +static const QMetaObject *qtscript_Qt_metaObject() +{ + return qtscript_Qt_metaObject_helper::get(); +} + +Q_DECLARE_METATYPE(Qt::CursorShape) +Q_DECLARE_METATYPE(Qt::Corner) +Q_DECLARE_METATYPE(Qt::Axis) +Q_DECLARE_METATYPE(Qt::Orientation) +Q_DECLARE_METATYPE(QFlags<Qt::Orientation>) +Q_DECLARE_METATYPE(Qt::LayoutDirection) +Q_DECLARE_METATYPE(Qt::BGMode) +Q_DECLARE_METATYPE(Qt::AspectRatioMode) +Q_DECLARE_METATYPE(Qt::TextElideMode) +Q_DECLARE_METATYPE(Qt::SizeMode) +Q_DECLARE_METATYPE(Qt::WindowType) +Q_DECLARE_METATYPE(QFlags<Qt::WindowType>) +Q_DECLARE_METATYPE(Qt::ItemDataRole) +Q_DECLARE_METATYPE(Qt::SortOrder) +Q_DECLARE_METATYPE(Qt::MatchFlag) +Q_DECLARE_METATYPE(QFlags<Qt::MatchFlag>) +Q_DECLARE_METATYPE(Qt::PenJoinStyle) +Q_DECLARE_METATYPE(Qt::CaseSensitivity) +Q_DECLARE_METATYPE(Qt::BrushStyle) +Q_DECLARE_METATYPE(Qt::ClipOperation) +Q_DECLARE_METATYPE(Qt::FocusReason) +Q_DECLARE_METATYPE(Qt::ToolBarArea) +Q_DECLARE_METATYPE(QFlags<Qt::ToolBarArea>) +Q_DECLARE_METATYPE(Qt::KeyboardModifier) +Q_DECLARE_METATYPE(QFlags<Qt::KeyboardModifier>) +Q_DECLARE_METATYPE(Qt::WhiteSpaceMode) +Q_DECLARE_METATYPE(Qt::DayOfWeek) +Q_DECLARE_METATYPE(Qt::EventPriority) +Q_DECLARE_METATYPE(Qt::DateFormat) +Q_DECLARE_METATYPE(Qt::MaskMode) +Q_DECLARE_METATYPE(Qt::UIEffect) +Q_DECLARE_METATYPE(Qt::ContextMenuPolicy) +Q_DECLARE_METATYPE(Qt::AnchorAttribute) +Q_DECLARE_METATYPE(Qt::ScrollBarPolicy) +Q_DECLARE_METATYPE(Qt::ToolButtonStyle) +Q_DECLARE_METATYPE(Qt::TextFlag) +Q_DECLARE_METATYPE(Qt::ItemSelectionMode) +Q_DECLARE_METATYPE(Qt::SizeHint) +Q_DECLARE_METATYPE(Qt::Key) +Q_DECLARE_METATYPE(Qt::ToolBarAreaSizes) +Q_DECLARE_METATYPE(Qt::ArrowType) +Q_DECLARE_METATYPE(Qt::FocusPolicy) +Q_DECLARE_METATYPE(Qt::WindowFrameSection) +Q_DECLARE_METATYPE(Qt::InputMethodQuery) +Q_DECLARE_METATYPE(Qt::DropAction) +Q_DECLARE_METATYPE(QFlags<Qt::DropAction>) +Q_DECLARE_METATYPE(Qt::FillRule) +Q_DECLARE_METATYPE(Qt::GlobalColor) +Q_DECLARE_METATYPE(Qt::ConnectionType) +Q_DECLARE_METATYPE(Qt::PenCapStyle) +Q_DECLARE_METATYPE(Qt::TransformationMode) +Q_DECLARE_METATYPE(Qt::DockWidgetAreaSizes) +Q_DECLARE_METATYPE(Qt::ApplicationAttribute) +Q_DECLARE_METATYPE(Qt::ShortcutContext) +Q_DECLARE_METATYPE(Qt::TextInteractionFlag) +Q_DECLARE_METATYPE(QFlags<Qt::TextInteractionFlag>) +Q_DECLARE_METATYPE(Qt::CheckState) +Q_DECLARE_METATYPE(Qt::DockWidgetArea) +Q_DECLARE_METATYPE(QFlags<Qt::DockWidgetArea>) +Q_DECLARE_METATYPE(Qt::TimeSpec) +Q_DECLARE_METATYPE(Qt::ImageConversionFlag) +Q_DECLARE_METATYPE(QFlags<Qt::ImageConversionFlag>) +Q_DECLARE_METATYPE(Qt::WindowModality) +Q_DECLARE_METATYPE(Qt::Modifier) +Q_DECLARE_METATYPE(Qt::AlignmentFlag) +Q_DECLARE_METATYPE(QFlags<Qt::AlignmentFlag>) +Q_DECLARE_METATYPE(Qt::WidgetAttribute) +Q_DECLARE_METATYPE(Qt::TextFormat) +Q_DECLARE_METATYPE(Qt::MouseButton) +Q_DECLARE_METATYPE(QFlags<Qt::MouseButton>) +Q_DECLARE_METATYPE(Qt::WindowState) +Q_DECLARE_METATYPE(QFlags<Qt::WindowState>) +Q_DECLARE_METATYPE(Qt::PenStyle) +Q_DECLARE_METATYPE(Qt::ItemFlag) +Q_DECLARE_METATYPE(QFlags<Qt::ItemFlag>) +Q_DECLARE_METATYPE(Qt::HitTestAccuracy) + +static QScriptValue qtscript_create_enum_class_helper( + QScriptEngine *engine, + QScriptEngine::FunctionSignature construct, + QScriptEngine::FunctionSignature valueOf, + QScriptEngine::FunctionSignature toString) +{ + QScriptValue proto = engine->newObject(); + proto.setProperty(QString::fromLatin1("valueOf"), + engine->newFunction(valueOf), QScriptValue::SkipInEnumeration); + proto.setProperty(QString::fromLatin1("toString"), + engine->newFunction(toString), QScriptValue::SkipInEnumeration); + return engine->newFunction(construct, proto, 1); +} + +static QScriptValue qtscript_create_flags_class_helper( + QScriptEngine *engine, + QScriptEngine::FunctionSignature construct, + QScriptEngine::FunctionSignature valueOf, + QScriptEngine::FunctionSignature toString, + QScriptEngine::FunctionSignature equals) +{ + QScriptValue proto = engine->newObject(); + proto.setProperty(QString::fromLatin1("valueOf"), + engine->newFunction(valueOf), QScriptValue::SkipInEnumeration); + proto.setProperty(QString::fromLatin1("toString"), + engine->newFunction(toString), QScriptValue::SkipInEnumeration); + proto.setProperty(QString::fromLatin1("equals"), + engine->newFunction(equals), QScriptValue::SkipInEnumeration); + return engine->newFunction(construct, proto); +} + +// +// Qt::CursorShape +// + +static const Qt::CursorShape qtscript_Qt_CursorShape_values[] = { + Qt::ArrowCursor + , Qt::UpArrowCursor + , Qt::CrossCursor + , Qt::WaitCursor + , Qt::IBeamCursor + , Qt::SizeVerCursor + , Qt::SizeHorCursor + , Qt::SizeBDiagCursor + , Qt::SizeFDiagCursor + , Qt::SizeAllCursor + , Qt::BlankCursor + , Qt::SplitVCursor + , Qt::SplitHCursor + , Qt::PointingHandCursor + , Qt::ForbiddenCursor + , Qt::WhatsThisCursor + , Qt::BusyCursor + , Qt::OpenHandCursor + , Qt::ClosedHandCursor + , Qt::BitmapCursor + , Qt::CustomCursor +}; + +static const char * const qtscript_Qt_CursorShape_keys[] = { + "ArrowCursor" + , "UpArrowCursor" + , "CrossCursor" + , "WaitCursor" + , "IBeamCursor" + , "SizeVerCursor" + , "SizeHorCursor" + , "SizeBDiagCursor" + , "SizeFDiagCursor" + , "SizeAllCursor" + , "BlankCursor" + , "SplitVCursor" + , "SplitHCursor" + , "PointingHandCursor" + , "ForbiddenCursor" + , "WhatsThisCursor" + , "BusyCursor" + , "OpenHandCursor" + , "ClosedHandCursor" + , "BitmapCursor" + , "CustomCursor" +}; + +static QString qtscript_Qt_CursorShape_toStringHelper(Qt::CursorShape value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CursorShape"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_CursorShape_toScriptValue(QScriptEngine *engine, const Qt::CursorShape &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_CursorShape_toStringHelper(value)); +} + +static void qtscript_Qt_CursorShape_fromScriptValue(const QScriptValue &value, Qt::CursorShape &out) +{ + out = qvariant_cast<Qt::CursorShape>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_CursorShape(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CursorShape"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::CursorShape>(arg)); + return context->throwError(QString::fromLatin1("CursorShape(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_CursorShape_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CursorShape value = qscriptvalue_cast<Qt::CursorShape>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_CursorShape_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CursorShape value = qscriptvalue_cast<Qt::CursorShape>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_CursorShape_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_CursorShape_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_CursorShape, + qtscript_Qt_CursorShape_valueOf, qtscript_Qt_CursorShape_toString); + qScriptRegisterMetaType<Qt::CursorShape>(engine, qtscript_Qt_CursorShape_toScriptValue, + qtscript_Qt_CursorShape_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 21; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_CursorShape_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_CursorShape_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Corner +// + +static const Qt::Corner qtscript_Qt_Corner_values[] = { + Qt::TopLeftCorner + , Qt::TopRightCorner + , Qt::BottomLeftCorner + , Qt::BottomRightCorner +}; + +static const char * const qtscript_Qt_Corner_keys[] = { + "TopLeftCorner" + , "TopRightCorner" + , "BottomLeftCorner" + , "BottomRightCorner" +}; + +static QString qtscript_Qt_Corner_toStringHelper(Qt::Corner value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Corner"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_Corner_toScriptValue(QScriptEngine *engine, const Qt::Corner &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_Corner_toStringHelper(value)); +} + +static void qtscript_Qt_Corner_fromScriptValue(const QScriptValue &value, Qt::Corner &out) +{ + out = qvariant_cast<Qt::Corner>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_Corner(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Corner"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::Corner>(arg)); + return context->throwError(QString::fromLatin1("Corner(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_Corner_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Corner value = qscriptvalue_cast<Qt::Corner>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Corner_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Corner value = qscriptvalue_cast<Qt::Corner>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_Corner_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_Corner_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_Corner, + qtscript_Qt_Corner_valueOf, qtscript_Qt_Corner_toString); + qScriptRegisterMetaType<Qt::Corner>(engine, qtscript_Qt_Corner_toScriptValue, + qtscript_Qt_Corner_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_Corner_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_Corner_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Axis +// + +static const Qt::Axis qtscript_Qt_Axis_values[] = { + Qt::XAxis + , Qt::YAxis + , Qt::ZAxis +}; + +static const char * const qtscript_Qt_Axis_keys[] = { + "XAxis" + , "YAxis" + , "ZAxis" +}; + +static QString qtscript_Qt_Axis_toStringHelper(Qt::Axis value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Axis"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_Axis_toScriptValue(QScriptEngine *engine, const Qt::Axis &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_Axis_toStringHelper(value)); +} + +static void qtscript_Qt_Axis_fromScriptValue(const QScriptValue &value, Qt::Axis &out) +{ + out = qvariant_cast<Qt::Axis>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_Axis(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Axis"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::Axis>(arg)); + return context->throwError(QString::fromLatin1("Axis(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_Axis_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Axis value = qscriptvalue_cast<Qt::Axis>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Axis_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Axis value = qscriptvalue_cast<Qt::Axis>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_Axis_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_Axis_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_Axis, + qtscript_Qt_Axis_valueOf, qtscript_Qt_Axis_toString); + qScriptRegisterMetaType<Qt::Axis>(engine, qtscript_Qt_Axis_toScriptValue, + qtscript_Qt_Axis_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_Axis_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_Axis_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Orientation +// + +static const Qt::Orientation qtscript_Qt_Orientation_values[] = { + Qt::Horizontal + , Qt::Vertical +}; + +static const char * const qtscript_Qt_Orientation_keys[] = { + "Horizontal" + , "Vertical" +}; + +static QString qtscript_Qt_Orientation_toStringHelper(Qt::Orientation value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Orientation"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_Orientation_toScriptValue(QScriptEngine *engine, const Qt::Orientation &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_Orientation_toStringHelper(value)); +} + +static void qtscript_Qt_Orientation_fromScriptValue(const QScriptValue &value, Qt::Orientation &out) +{ + out = qvariant_cast<Qt::Orientation>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_Orientation(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Orientation"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::Orientation>(arg)); + return context->throwError(QString::fromLatin1("Orientation(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_Orientation_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Orientation value = qscriptvalue_cast<Qt::Orientation>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Orientation_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Orientation value = qscriptvalue_cast<Qt::Orientation>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_Orientation_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_Orientation_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_Orientation, + qtscript_Qt_Orientation_valueOf, qtscript_Qt_Orientation_toString); + qScriptRegisterMetaType<Qt::Orientation>(engine, qtscript_Qt_Orientation_toScriptValue, + qtscript_Qt_Orientation_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_Orientation_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_Orientation_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Orientations +// + +static QScriptValue qtscript_Qt_Orientations_toScriptValue(QScriptEngine *engine, const Qt::Orientations &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_Orientations_fromScriptValue(const QScriptValue &value, Qt::Orientations &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::Orientations>()) + out = qvariant_cast<Qt::Orientations>(var); + else if (var.userType() == qMetaTypeId<Qt::Orientation>()) + out = qvariant_cast<Qt::Orientation>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_Orientations(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Orientations result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::Orientations>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::Orientation>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("Orientations(): argument %0 is not of type Orientation").arg(i)); + } + result |= qvariant_cast<Qt::Orientation>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_Orientations_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Orientations value = qscriptvalue_cast<Qt::Orientations>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Orientations_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Orientations value = qscriptvalue_cast<Qt::Orientations>(context->thisObject()); + QString result; + for (int i = 0; i < 2; ++i) { + if ((value & qtscript_Qt_Orientation_values[i]) == qtscript_Qt_Orientation_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_Orientation_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_Orientations_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::Orientations>() == otherObj.value<Qt::Orientations>()))); +} + +static QScriptValue qtscript_create_Qt_Orientations_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_Orientations, qtscript_Qt_Orientations_valueOf, + qtscript_Qt_Orientations_toString, qtscript_Qt_Orientations_equals); + qScriptRegisterMetaType<Qt::Orientations>(engine, qtscript_Qt_Orientations_toScriptValue, + qtscript_Qt_Orientations_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::LayoutDirection +// + +static const Qt::LayoutDirection qtscript_Qt_LayoutDirection_values[] = { + Qt::LeftToRight + , Qt::RightToLeft +}; + +static const char * const qtscript_Qt_LayoutDirection_keys[] = { + "LeftToRight" + , "RightToLeft" +}; + +static QString qtscript_Qt_LayoutDirection_toStringHelper(Qt::LayoutDirection value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("LayoutDirection"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_LayoutDirection_toScriptValue(QScriptEngine *engine, const Qt::LayoutDirection &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_LayoutDirection_toStringHelper(value)); +} + +static void qtscript_Qt_LayoutDirection_fromScriptValue(const QScriptValue &value, Qt::LayoutDirection &out) +{ + out = qvariant_cast<Qt::LayoutDirection>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_LayoutDirection(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("LayoutDirection"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::LayoutDirection>(arg)); + return context->throwError(QString::fromLatin1("LayoutDirection(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_LayoutDirection_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::LayoutDirection value = qscriptvalue_cast<Qt::LayoutDirection>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_LayoutDirection_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::LayoutDirection value = qscriptvalue_cast<Qt::LayoutDirection>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_LayoutDirection_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_LayoutDirection_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_LayoutDirection, + qtscript_Qt_LayoutDirection_valueOf, qtscript_Qt_LayoutDirection_toString); + qScriptRegisterMetaType<Qt::LayoutDirection>(engine, qtscript_Qt_LayoutDirection_toScriptValue, + qtscript_Qt_LayoutDirection_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_LayoutDirection_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_LayoutDirection_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::BGMode +// + +static const Qt::BGMode qtscript_Qt_BGMode_values[] = { + Qt::TransparentMode + , Qt::OpaqueMode +}; + +static const char * const qtscript_Qt_BGMode_keys[] = { + "TransparentMode" + , "OpaqueMode" +}; + +static QString qtscript_Qt_BGMode_toStringHelper(Qt::BGMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("BGMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_BGMode_toScriptValue(QScriptEngine *engine, const Qt::BGMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_BGMode_toStringHelper(value)); +} + +static void qtscript_Qt_BGMode_fromScriptValue(const QScriptValue &value, Qt::BGMode &out) +{ + out = qvariant_cast<Qt::BGMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_BGMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("BGMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::BGMode>(arg)); + return context->throwError(QString::fromLatin1("BGMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_BGMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::BGMode value = qscriptvalue_cast<Qt::BGMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_BGMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::BGMode value = qscriptvalue_cast<Qt::BGMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_BGMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_BGMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_BGMode, + qtscript_Qt_BGMode_valueOf, qtscript_Qt_BGMode_toString); + qScriptRegisterMetaType<Qt::BGMode>(engine, qtscript_Qt_BGMode_toScriptValue, + qtscript_Qt_BGMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_BGMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_BGMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::AspectRatioMode +// + +static const Qt::AspectRatioMode qtscript_Qt_AspectRatioMode_values[] = { + Qt::IgnoreAspectRatio + , Qt::KeepAspectRatio + , Qt::KeepAspectRatioByExpanding +}; + +static const char * const qtscript_Qt_AspectRatioMode_keys[] = { + "IgnoreAspectRatio" + , "KeepAspectRatio" + , "KeepAspectRatioByExpanding" +}; + +static QString qtscript_Qt_AspectRatioMode_toStringHelper(Qt::AspectRatioMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("AspectRatioMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_AspectRatioMode_toScriptValue(QScriptEngine *engine, const Qt::AspectRatioMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_AspectRatioMode_toStringHelper(value)); +} + +static void qtscript_Qt_AspectRatioMode_fromScriptValue(const QScriptValue &value, Qt::AspectRatioMode &out) +{ + out = qvariant_cast<Qt::AspectRatioMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_AspectRatioMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("AspectRatioMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::AspectRatioMode>(arg)); + return context->throwError(QString::fromLatin1("AspectRatioMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_AspectRatioMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AspectRatioMode value = qscriptvalue_cast<Qt::AspectRatioMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_AspectRatioMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AspectRatioMode value = qscriptvalue_cast<Qt::AspectRatioMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_AspectRatioMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_AspectRatioMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_AspectRatioMode, + qtscript_Qt_AspectRatioMode_valueOf, qtscript_Qt_AspectRatioMode_toString); + qScriptRegisterMetaType<Qt::AspectRatioMode>(engine, qtscript_Qt_AspectRatioMode_toScriptValue, + qtscript_Qt_AspectRatioMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_AspectRatioMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_AspectRatioMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TextElideMode +// + +static const Qt::TextElideMode qtscript_Qt_TextElideMode_values[] = { + Qt::ElideLeft + , Qt::ElideRight + , Qt::ElideMiddle + , Qt::ElideNone +}; + +static const char * const qtscript_Qt_TextElideMode_keys[] = { + "ElideLeft" + , "ElideRight" + , "ElideMiddle" + , "ElideNone" +}; + +static QString qtscript_Qt_TextElideMode_toStringHelper(Qt::TextElideMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextElideMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_TextElideMode_toScriptValue(QScriptEngine *engine, const Qt::TextElideMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TextElideMode_toStringHelper(value)); +} + +static void qtscript_Qt_TextElideMode_fromScriptValue(const QScriptValue &value, Qt::TextElideMode &out) +{ + out = qvariant_cast<Qt::TextElideMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TextElideMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextElideMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::TextElideMode>(arg)); + return context->throwError(QString::fromLatin1("TextElideMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TextElideMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextElideMode value = qscriptvalue_cast<Qt::TextElideMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TextElideMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextElideMode value = qscriptvalue_cast<Qt::TextElideMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TextElideMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TextElideMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TextElideMode, + qtscript_Qt_TextElideMode_valueOf, qtscript_Qt_TextElideMode_toString); + qScriptRegisterMetaType<Qt::TextElideMode>(engine, qtscript_Qt_TextElideMode_toScriptValue, + qtscript_Qt_TextElideMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TextElideMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TextElideMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::SizeMode +// + +static const Qt::SizeMode qtscript_Qt_SizeMode_values[] = { + Qt::AbsoluteSize + , Qt::RelativeSize +}; + +static const char * const qtscript_Qt_SizeMode_keys[] = { + "AbsoluteSize" + , "RelativeSize" +}; + +static QString qtscript_Qt_SizeMode_toStringHelper(Qt::SizeMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SizeMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_SizeMode_toScriptValue(QScriptEngine *engine, const Qt::SizeMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_SizeMode_toStringHelper(value)); +} + +static void qtscript_Qt_SizeMode_fromScriptValue(const QScriptValue &value, Qt::SizeMode &out) +{ + out = qvariant_cast<Qt::SizeMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_SizeMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SizeMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::SizeMode>(arg)); + return context->throwError(QString::fromLatin1("SizeMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_SizeMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SizeMode value = qscriptvalue_cast<Qt::SizeMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_SizeMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SizeMode value = qscriptvalue_cast<Qt::SizeMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_SizeMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_SizeMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_SizeMode, + qtscript_Qt_SizeMode_valueOf, qtscript_Qt_SizeMode_toString); + qScriptRegisterMetaType<Qt::SizeMode>(engine, qtscript_Qt_SizeMode_toScriptValue, + qtscript_Qt_SizeMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_SizeMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_SizeMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::WindowType +// + +static const Qt::WindowType qtscript_Qt_WindowType_values[] = { + Qt::Widget + , Qt::Window + , Qt::Dialog + , Qt::Sheet + , Qt::Drawer + , Qt::Popup + , Qt::Tool + , Qt::ToolTip + , Qt::SplashScreen + , Qt::Desktop + , Qt::SubWindow + , Qt::WindowType_Mask + , Qt::MSWindowsFixedSizeDialogHint + , Qt::MSWindowsOwnDC + , Qt::X11BypassWindowManagerHint + , Qt::FramelessWindowHint + , Qt::WindowTitleHint + , Qt::WindowSystemMenuHint + , Qt::WindowMinimizeButtonHint + , Qt::WindowMaximizeButtonHint + , Qt::WindowMinMaxButtonsHint + , Qt::WindowContextHelpButtonHint + , Qt::WindowShadeButtonHint + , Qt::WindowStaysOnTopHint + , Qt::WindowOkButtonHint + , Qt::WindowCancelButtonHint + , Qt::CustomizeWindowHint + , Qt::WindowStaysOnBottomHint + , Qt::WindowCloseButtonHint + , Qt::MacWindowToolBarButtonHint + , Qt::BypassGraphicsProxyWidget +}; + +static const char * const qtscript_Qt_WindowType_keys[] = { + "Widget" + , "Window" + , "Dialog" + , "Sheet" + , "Drawer" + , "Popup" + , "Tool" + , "ToolTip" + , "SplashScreen" + , "Desktop" + , "SubWindow" + , "WindowType_Mask" + , "MSWindowsFixedSizeDialogHint" + , "MSWindowsOwnDC" + , "X11BypassWindowManagerHint" + , "FramelessWindowHint" + , "WindowTitleHint" + , "WindowSystemMenuHint" + , "WindowMinimizeButtonHint" + , "WindowMaximizeButtonHint" + , "WindowMinMaxButtonsHint" + , "WindowContextHelpButtonHint" + , "WindowShadeButtonHint" + , "WindowStaysOnTopHint" + , "WindowOkButtonHint" + , "WindowCancelButtonHint" + , "CustomizeWindowHint" + , "WindowStaysOnBottomHint" + , "WindowCloseButtonHint" + , "MacWindowToolBarButtonHint" + , "BypassGraphicsProxyWidget" +}; + +static QString qtscript_Qt_WindowType_toStringHelper(Qt::WindowType value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_WindowType_toScriptValue(QScriptEngine *engine, const Qt::WindowType &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WindowType_toStringHelper(value)); +} + +static void qtscript_Qt_WindowType_fromScriptValue(const QScriptValue &value, Qt::WindowType &out) +{ + out = qvariant_cast<Qt::WindowType>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WindowType(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::WindowType>(arg)); + return context->throwError(QString::fromLatin1("WindowType(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WindowType_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowType value = qscriptvalue_cast<Qt::WindowType>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowType_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowType value = qscriptvalue_cast<Qt::WindowType>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WindowType_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WindowType_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WindowType, + qtscript_Qt_WindowType_valueOf, qtscript_Qt_WindowType_toString); + qScriptRegisterMetaType<Qt::WindowType>(engine, qtscript_Qt_WindowType_toScriptValue, + qtscript_Qt_WindowType_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 31; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WindowType_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WindowType_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::WindowFlags +// + +static QScriptValue qtscript_Qt_WindowFlags_toScriptValue(QScriptEngine *engine, const Qt::WindowFlags &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_WindowFlags_fromScriptValue(const QScriptValue &value, Qt::WindowFlags &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::WindowFlags>()) + out = qvariant_cast<Qt::WindowFlags>(var); + else if (var.userType() == qMetaTypeId<Qt::WindowType>()) + out = qvariant_cast<Qt::WindowType>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_WindowFlags(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowFlags result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::WindowFlags>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::WindowType>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("WindowFlags(): argument %0 is not of type WindowType").arg(i)); + } + result |= qvariant_cast<Qt::WindowType>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_WindowFlags_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowFlags value = qscriptvalue_cast<Qt::WindowFlags>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowFlags_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowFlags value = qscriptvalue_cast<Qt::WindowFlags>(context->thisObject()); + QString result; + for (int i = 0; i < 31; ++i) { + if ((value & qtscript_Qt_WindowType_values[i]) == qtscript_Qt_WindowType_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_WindowType_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_WindowFlags_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::WindowFlags>() == otherObj.value<Qt::WindowFlags>()))); +} + +static QScriptValue qtscript_create_Qt_WindowFlags_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_WindowFlags, qtscript_Qt_WindowFlags_valueOf, + qtscript_Qt_WindowFlags_toString, qtscript_Qt_WindowFlags_equals); + qScriptRegisterMetaType<Qt::WindowFlags>(engine, qtscript_Qt_WindowFlags_toScriptValue, + qtscript_Qt_WindowFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::ItemDataRole +// + +static const Qt::ItemDataRole qtscript_Qt_ItemDataRole_values[] = { + Qt::DisplayRole + , Qt::DecorationRole + , Qt::EditRole + , Qt::ToolTipRole + , Qt::StatusTipRole + , Qt::WhatsThisRole + , Qt::FontRole + , Qt::TextAlignmentRole + , Qt::BackgroundColorRole + , Qt::TextColorRole + , Qt::CheckStateRole + , Qt::AccessibleTextRole + , Qt::AccessibleDescriptionRole + , Qt::SizeHintRole + , Qt::DisplayPropertyRole + , Qt::DecorationPropertyRole + , Qt::ToolTipPropertyRole + , Qt::StatusTipPropertyRole + , Qt::WhatsThisPropertyRole + , Qt::UserRole +}; + +static const char * const qtscript_Qt_ItemDataRole_keys[] = { + "DisplayRole" + , "DecorationRole" + , "EditRole" + , "ToolTipRole" + , "StatusTipRole" + , "WhatsThisRole" + , "FontRole" + , "TextAlignmentRole" + , "BackgroundColorRole" + , "TextColorRole" + , "CheckStateRole" + , "AccessibleTextRole" + , "AccessibleDescriptionRole" + , "SizeHintRole" + , "DisplayPropertyRole" + , "DecorationPropertyRole" + , "ToolTipPropertyRole" + , "StatusTipPropertyRole" + , "WhatsThisPropertyRole" + , "UserRole" +}; + +static QString qtscript_Qt_ItemDataRole_toStringHelper(Qt::ItemDataRole value) +{ + for (int i = 0; i < 20; ++i) { + if (qtscript_Qt_ItemDataRole_values[i] == value) + return QString::fromLatin1(qtscript_Qt_ItemDataRole_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_ItemDataRole_toScriptValue(QScriptEngine *engine, const Qt::ItemDataRole &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ItemDataRole_toStringHelper(value)); +} + +static void qtscript_Qt_ItemDataRole_fromScriptValue(const QScriptValue &value, Qt::ItemDataRole &out) +{ + out = qvariant_cast<Qt::ItemDataRole>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ItemDataRole(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 20; ++i) { + if (qtscript_Qt_ItemDataRole_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::ItemDataRole>(arg)); + } + return context->throwError(QString::fromLatin1("ItemDataRole(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ItemDataRole_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemDataRole value = qscriptvalue_cast<Qt::ItemDataRole>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ItemDataRole_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemDataRole value = qscriptvalue_cast<Qt::ItemDataRole>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ItemDataRole_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ItemDataRole_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ItemDataRole, + qtscript_Qt_ItemDataRole_valueOf, qtscript_Qt_ItemDataRole_toString); + qScriptRegisterMetaType<Qt::ItemDataRole>(engine, qtscript_Qt_ItemDataRole_toScriptValue, + qtscript_Qt_ItemDataRole_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 20; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ItemDataRole_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ItemDataRole_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::SortOrder +// + +static const Qt::SortOrder qtscript_Qt_SortOrder_values[] = { + Qt::AscendingOrder + , Qt::DescendingOrder +}; + +static const char * const qtscript_Qt_SortOrder_keys[] = { + "AscendingOrder" + , "DescendingOrder" +}; + +static QString qtscript_Qt_SortOrder_toStringHelper(Qt::SortOrder value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SortOrder"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_SortOrder_toScriptValue(QScriptEngine *engine, const Qt::SortOrder &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_SortOrder_toStringHelper(value)); +} + +static void qtscript_Qt_SortOrder_fromScriptValue(const QScriptValue &value, Qt::SortOrder &out) +{ + out = qvariant_cast<Qt::SortOrder>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_SortOrder(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SortOrder"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::SortOrder>(arg)); + return context->throwError(QString::fromLatin1("SortOrder(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_SortOrder_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SortOrder value = qscriptvalue_cast<Qt::SortOrder>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_SortOrder_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SortOrder value = qscriptvalue_cast<Qt::SortOrder>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_SortOrder_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_SortOrder_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_SortOrder, + qtscript_Qt_SortOrder_valueOf, qtscript_Qt_SortOrder_toString); + qScriptRegisterMetaType<Qt::SortOrder>(engine, qtscript_Qt_SortOrder_toScriptValue, + qtscript_Qt_SortOrder_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_SortOrder_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_SortOrder_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::MatchFlag +// + +static const Qt::MatchFlag qtscript_Qt_MatchFlag_values[] = { + Qt::MatchExactly + , Qt::MatchContains + , Qt::MatchStartsWith + , Qt::MatchEndsWith + , Qt::MatchRegExp + , Qt::MatchWildcard + , Qt::MatchFixedString + , Qt::MatchCaseSensitive + , Qt::MatchWrap + , Qt::MatchRecursive +}; + +static const char * const qtscript_Qt_MatchFlag_keys[] = { + "MatchExactly" + , "MatchContains" + , "MatchStartsWith" + , "MatchEndsWith" + , "MatchRegExp" + , "MatchWildcard" + , "MatchFixedString" + , "MatchCaseSensitive" + , "MatchWrap" + , "MatchRecursive" +}; + +static QString qtscript_Qt_MatchFlag_toStringHelper(Qt::MatchFlag value) +{ + for (int i = 0; i < 10; ++i) { + if (qtscript_Qt_MatchFlag_values[i] == value) + return QString::fromLatin1(qtscript_Qt_MatchFlag_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_MatchFlag_toScriptValue(QScriptEngine *engine, const Qt::MatchFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_MatchFlag_toStringHelper(value)); +} + +static void qtscript_Qt_MatchFlag_fromScriptValue(const QScriptValue &value, Qt::MatchFlag &out) +{ + out = qvariant_cast<Qt::MatchFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_MatchFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 10; ++i) { + if (qtscript_Qt_MatchFlag_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::MatchFlag>(arg)); + } + return context->throwError(QString::fromLatin1("MatchFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_MatchFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MatchFlag value = qscriptvalue_cast<Qt::MatchFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_MatchFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MatchFlag value = qscriptvalue_cast<Qt::MatchFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_MatchFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_MatchFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_MatchFlag, + qtscript_Qt_MatchFlag_valueOf, qtscript_Qt_MatchFlag_toString); + qScriptRegisterMetaType<Qt::MatchFlag>(engine, qtscript_Qt_MatchFlag_toScriptValue, + qtscript_Qt_MatchFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 10; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_MatchFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_MatchFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::MatchFlags +// + +static QScriptValue qtscript_Qt_MatchFlags_toScriptValue(QScriptEngine *engine, const Qt::MatchFlags &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_MatchFlags_fromScriptValue(const QScriptValue &value, Qt::MatchFlags &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::MatchFlags>()) + out = qvariant_cast<Qt::MatchFlags>(var); + else if (var.userType() == qMetaTypeId<Qt::MatchFlag>()) + out = qvariant_cast<Qt::MatchFlag>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_MatchFlags(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MatchFlags result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::MatchFlags>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::MatchFlag>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("MatchFlags(): argument %0 is not of type MatchFlag").arg(i)); + } + result |= qvariant_cast<Qt::MatchFlag>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_MatchFlags_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MatchFlags value = qscriptvalue_cast<Qt::MatchFlags>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_MatchFlags_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MatchFlags value = qscriptvalue_cast<Qt::MatchFlags>(context->thisObject()); + QString result; + for (int i = 0; i < 10; ++i) { + if ((value & qtscript_Qt_MatchFlag_values[i]) == qtscript_Qt_MatchFlag_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_MatchFlag_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_MatchFlags_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::MatchFlags>() == otherObj.value<Qt::MatchFlags>()))); +} + +static QScriptValue qtscript_create_Qt_MatchFlags_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_MatchFlags, qtscript_Qt_MatchFlags_valueOf, + qtscript_Qt_MatchFlags_toString, qtscript_Qt_MatchFlags_equals); + qScriptRegisterMetaType<Qt::MatchFlags>(engine, qtscript_Qt_MatchFlags_toScriptValue, + qtscript_Qt_MatchFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::PenJoinStyle +// + +static const Qt::PenJoinStyle qtscript_Qt_PenJoinStyle_values[] = { + Qt::MiterJoin + , Qt::BevelJoin + , Qt::RoundJoin + , Qt::SvgMiterJoin + , Qt::MPenJoinStyle +}; + +static const char * const qtscript_Qt_PenJoinStyle_keys[] = { + "MiterJoin" + , "BevelJoin" + , "RoundJoin" + , "SvgMiterJoin" + , "MPenJoinStyle" +}; + +static QString qtscript_Qt_PenJoinStyle_toStringHelper(Qt::PenJoinStyle value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenJoinStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_PenJoinStyle_toScriptValue(QScriptEngine *engine, const Qt::PenJoinStyle &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_PenJoinStyle_toStringHelper(value)); +} + +static void qtscript_Qt_PenJoinStyle_fromScriptValue(const QScriptValue &value, Qt::PenJoinStyle &out) +{ + out = qvariant_cast<Qt::PenJoinStyle>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_PenJoinStyle(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenJoinStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::PenJoinStyle>(arg)); + return context->throwError(QString::fromLatin1("PenJoinStyle(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_PenJoinStyle_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenJoinStyle value = qscriptvalue_cast<Qt::PenJoinStyle>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_PenJoinStyle_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenJoinStyle value = qscriptvalue_cast<Qt::PenJoinStyle>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_PenJoinStyle_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_PenJoinStyle_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_PenJoinStyle, + qtscript_Qt_PenJoinStyle_valueOf, qtscript_Qt_PenJoinStyle_toString); + qScriptRegisterMetaType<Qt::PenJoinStyle>(engine, qtscript_Qt_PenJoinStyle_toScriptValue, + qtscript_Qt_PenJoinStyle_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_PenJoinStyle_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_PenJoinStyle_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::CaseSensitivity +// + +static const Qt::CaseSensitivity qtscript_Qt_CaseSensitivity_values[] = { + Qt::CaseInsensitive + , Qt::CaseSensitive +}; + +static const char * const qtscript_Qt_CaseSensitivity_keys[] = { + "CaseInsensitive" + , "CaseSensitive" +}; + +static QString qtscript_Qt_CaseSensitivity_toStringHelper(Qt::CaseSensitivity value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CaseSensitivity"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_CaseSensitivity_toScriptValue(QScriptEngine *engine, const Qt::CaseSensitivity &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_CaseSensitivity_toStringHelper(value)); +} + +static void qtscript_Qt_CaseSensitivity_fromScriptValue(const QScriptValue &value, Qt::CaseSensitivity &out) +{ + out = qvariant_cast<Qt::CaseSensitivity>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_CaseSensitivity(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CaseSensitivity"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::CaseSensitivity>(arg)); + return context->throwError(QString::fromLatin1("CaseSensitivity(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_CaseSensitivity_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CaseSensitivity value = qscriptvalue_cast<Qt::CaseSensitivity>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_CaseSensitivity_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CaseSensitivity value = qscriptvalue_cast<Qt::CaseSensitivity>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_CaseSensitivity_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_CaseSensitivity_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_CaseSensitivity, + qtscript_Qt_CaseSensitivity_valueOf, qtscript_Qt_CaseSensitivity_toString); + qScriptRegisterMetaType<Qt::CaseSensitivity>(engine, qtscript_Qt_CaseSensitivity_toScriptValue, + qtscript_Qt_CaseSensitivity_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_CaseSensitivity_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_CaseSensitivity_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::BrushStyle +// + +static const Qt::BrushStyle qtscript_Qt_BrushStyle_values[] = { + Qt::NoBrush + , Qt::SolidPattern + , Qt::Dense1Pattern + , Qt::Dense2Pattern + , Qt::Dense3Pattern + , Qt::Dense4Pattern + , Qt::Dense5Pattern + , Qt::Dense6Pattern + , Qt::Dense7Pattern + , Qt::HorPattern + , Qt::VerPattern + , Qt::CrossPattern + , Qt::BDiagPattern + , Qt::FDiagPattern + , Qt::DiagCrossPattern + , Qt::LinearGradientPattern + , Qt::RadialGradientPattern + , Qt::ConicalGradientPattern + , Qt::TexturePattern +}; + +static const char * const qtscript_Qt_BrushStyle_keys[] = { + "NoBrush" + , "SolidPattern" + , "Dense1Pattern" + , "Dense2Pattern" + , "Dense3Pattern" + , "Dense4Pattern" + , "Dense5Pattern" + , "Dense6Pattern" + , "Dense7Pattern" + , "HorPattern" + , "VerPattern" + , "CrossPattern" + , "BDiagPattern" + , "FDiagPattern" + , "DiagCrossPattern" + , "LinearGradientPattern" + , "RadialGradientPattern" + , "ConicalGradientPattern" + , "TexturePattern" +}; + +static QString qtscript_Qt_BrushStyle_toStringHelper(Qt::BrushStyle value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("BrushStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_BrushStyle_toScriptValue(QScriptEngine *engine, const Qt::BrushStyle &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_BrushStyle_toStringHelper(value)); +} + +static void qtscript_Qt_BrushStyle_fromScriptValue(const QScriptValue &value, Qt::BrushStyle &out) +{ + out = qvariant_cast<Qt::BrushStyle>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_BrushStyle(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("BrushStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::BrushStyle>(arg)); + return context->throwError(QString::fromLatin1("BrushStyle(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_BrushStyle_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::BrushStyle value = qscriptvalue_cast<Qt::BrushStyle>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_BrushStyle_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::BrushStyle value = qscriptvalue_cast<Qt::BrushStyle>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_BrushStyle_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_BrushStyle_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_BrushStyle, + qtscript_Qt_BrushStyle_valueOf, qtscript_Qt_BrushStyle_toString); + qScriptRegisterMetaType<Qt::BrushStyle>(engine, qtscript_Qt_BrushStyle_toScriptValue, + qtscript_Qt_BrushStyle_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 19; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_BrushStyle_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_BrushStyle_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ClipOperation +// + +static const Qt::ClipOperation qtscript_Qt_ClipOperation_values[] = { + Qt::NoClip + , Qt::ReplaceClip + , Qt::IntersectClip + , Qt::UniteClip +}; + +static const char * const qtscript_Qt_ClipOperation_keys[] = { + "NoClip" + , "ReplaceClip" + , "IntersectClip" + , "UniteClip" +}; + +static QString qtscript_Qt_ClipOperation_toStringHelper(Qt::ClipOperation value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ClipOperation"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ClipOperation_toScriptValue(QScriptEngine *engine, const Qt::ClipOperation &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ClipOperation_toStringHelper(value)); +} + +static void qtscript_Qt_ClipOperation_fromScriptValue(const QScriptValue &value, Qt::ClipOperation &out) +{ + out = qvariant_cast<Qt::ClipOperation>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ClipOperation(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ClipOperation"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ClipOperation>(arg)); + return context->throwError(QString::fromLatin1("ClipOperation(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ClipOperation_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ClipOperation value = qscriptvalue_cast<Qt::ClipOperation>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ClipOperation_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ClipOperation value = qscriptvalue_cast<Qt::ClipOperation>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ClipOperation_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ClipOperation_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ClipOperation, + qtscript_Qt_ClipOperation_valueOf, qtscript_Qt_ClipOperation_toString); + qScriptRegisterMetaType<Qt::ClipOperation>(engine, qtscript_Qt_ClipOperation_toScriptValue, + qtscript_Qt_ClipOperation_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ClipOperation_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ClipOperation_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::FocusReason +// + +static const Qt::FocusReason qtscript_Qt_FocusReason_values[] = { + Qt::MouseFocusReason + , Qt::TabFocusReason + , Qt::BacktabFocusReason + , Qt::ActiveWindowFocusReason + , Qt::PopupFocusReason + , Qt::ShortcutFocusReason + , Qt::MenuBarFocusReason + , Qt::OtherFocusReason + , Qt::NoFocusReason +}; + +static const char * const qtscript_Qt_FocusReason_keys[] = { + "MouseFocusReason" + , "TabFocusReason" + , "BacktabFocusReason" + , "ActiveWindowFocusReason" + , "PopupFocusReason" + , "ShortcutFocusReason" + , "MenuBarFocusReason" + , "OtherFocusReason" + , "NoFocusReason" +}; + +static QString qtscript_Qt_FocusReason_toStringHelper(Qt::FocusReason value) +{ + if ((value >= Qt::MouseFocusReason) && (value <= Qt::NoFocusReason)) + return qtscript_Qt_FocusReason_keys[static_cast<int>(value)-static_cast<int>(Qt::MouseFocusReason)]; + return QString(); +} + +static QScriptValue qtscript_Qt_FocusReason_toScriptValue(QScriptEngine *engine, const Qt::FocusReason &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_FocusReason_toStringHelper(value)); +} + +static void qtscript_Qt_FocusReason_fromScriptValue(const QScriptValue &value, Qt::FocusReason &out) +{ + out = qvariant_cast<Qt::FocusReason>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_FocusReason(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::MouseFocusReason) && (arg <= Qt::NoFocusReason)) + return qScriptValueFromValue(engine, static_cast<Qt::FocusReason>(arg)); + return context->throwError(QString::fromLatin1("FocusReason(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_FocusReason_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FocusReason value = qscriptvalue_cast<Qt::FocusReason>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_FocusReason_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FocusReason value = qscriptvalue_cast<Qt::FocusReason>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_FocusReason_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_FocusReason_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_FocusReason, + qtscript_Qt_FocusReason_valueOf, qtscript_Qt_FocusReason_toString); + qScriptRegisterMetaType<Qt::FocusReason>(engine, qtscript_Qt_FocusReason_toScriptValue, + qtscript_Qt_FocusReason_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 9; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_FocusReason_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_FocusReason_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ToolBarArea +// + +static const Qt::ToolBarArea qtscript_Qt_ToolBarArea_values[] = { + Qt::NoToolBarArea + , Qt::LeftToolBarArea + , Qt::RightToolBarArea + , Qt::TopToolBarArea + , Qt::BottomToolBarArea + , Qt::ToolBarArea_Mask +}; + +static const char * const qtscript_Qt_ToolBarArea_keys[] = { + "NoToolBarArea" + , "LeftToolBarArea" + , "RightToolBarArea" + , "TopToolBarArea" + , "BottomToolBarArea" + , "ToolBarArea_Mask" +}; + +static QString qtscript_Qt_ToolBarArea_toStringHelper(Qt::ToolBarArea value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ToolBarArea"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ToolBarArea_toScriptValue(QScriptEngine *engine, const Qt::ToolBarArea &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ToolBarArea_toStringHelper(value)); +} + +static void qtscript_Qt_ToolBarArea_fromScriptValue(const QScriptValue &value, Qt::ToolBarArea &out) +{ + out = qvariant_cast<Qt::ToolBarArea>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ToolBarArea(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ToolBarArea"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ToolBarArea>(arg)); + return context->throwError(QString::fromLatin1("ToolBarArea(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ToolBarArea_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarArea value = qscriptvalue_cast<Qt::ToolBarArea>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ToolBarArea_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarArea value = qscriptvalue_cast<Qt::ToolBarArea>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ToolBarArea_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ToolBarArea_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ToolBarArea, + qtscript_Qt_ToolBarArea_valueOf, qtscript_Qt_ToolBarArea_toString); + qScriptRegisterMetaType<Qt::ToolBarArea>(engine, qtscript_Qt_ToolBarArea_toScriptValue, + qtscript_Qt_ToolBarArea_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 6; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ToolBarArea_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ToolBarArea_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ToolBarAreas +// + +static QScriptValue qtscript_Qt_ToolBarAreas_toScriptValue(QScriptEngine *engine, const Qt::ToolBarAreas &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_ToolBarAreas_fromScriptValue(const QScriptValue &value, Qt::ToolBarAreas &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::ToolBarAreas>()) + out = qvariant_cast<Qt::ToolBarAreas>(var); + else if (var.userType() == qMetaTypeId<Qt::ToolBarArea>()) + out = qvariant_cast<Qt::ToolBarArea>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_ToolBarAreas(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarAreas result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::ToolBarAreas>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::ToolBarArea>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("ToolBarAreas(): argument %0 is not of type ToolBarArea").arg(i)); + } + result |= qvariant_cast<Qt::ToolBarArea>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_ToolBarAreas_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarAreas value = qscriptvalue_cast<Qt::ToolBarAreas>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ToolBarAreas_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarAreas value = qscriptvalue_cast<Qt::ToolBarAreas>(context->thisObject()); + QString result; + for (int i = 0; i < 6; ++i) { + if ((value & qtscript_Qt_ToolBarArea_values[i]) == qtscript_Qt_ToolBarArea_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_ToolBarArea_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_ToolBarAreas_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::ToolBarAreas>() == otherObj.value<Qt::ToolBarAreas>()))); +} + +static QScriptValue qtscript_create_Qt_ToolBarAreas_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_ToolBarAreas, qtscript_Qt_ToolBarAreas_valueOf, + qtscript_Qt_ToolBarAreas_toString, qtscript_Qt_ToolBarAreas_equals); + qScriptRegisterMetaType<Qt::ToolBarAreas>(engine, qtscript_Qt_ToolBarAreas_toScriptValue, + qtscript_Qt_ToolBarAreas_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::KeyboardModifier +// + +static const Qt::KeyboardModifier qtscript_Qt_KeyboardModifier_values[] = { + Qt::KeyboardModifierMask + , Qt::NoModifier + , Qt::ShiftModifier + , Qt::ControlModifier + , Qt::AltModifier + , Qt::MetaModifier + , Qt::KeypadModifier + , Qt::GroupSwitchModifier +}; + +static const char * const qtscript_Qt_KeyboardModifier_keys[] = { + "KeyboardModifierMask" + , "NoModifier" + , "ShiftModifier" + , "ControlModifier" + , "AltModifier" + , "MetaModifier" + , "KeypadModifier" + , "GroupSwitchModifier" +}; + +static QString qtscript_Qt_KeyboardModifier_toStringHelper(Qt::KeyboardModifier value) +{ + for (int i = 0; i < 8; ++i) { + if (qtscript_Qt_KeyboardModifier_values[i] == value) + return QString::fromLatin1(qtscript_Qt_KeyboardModifier_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_KeyboardModifier_toScriptValue(QScriptEngine *engine, const Qt::KeyboardModifier &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_KeyboardModifier_toStringHelper(value)); +} + +static void qtscript_Qt_KeyboardModifier_fromScriptValue(const QScriptValue &value, Qt::KeyboardModifier &out) +{ + out = qvariant_cast<Qt::KeyboardModifier>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_KeyboardModifier(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 8; ++i) { + if (qtscript_Qt_KeyboardModifier_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::KeyboardModifier>(arg)); + } + return context->throwError(QString::fromLatin1("KeyboardModifier(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_KeyboardModifier_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::KeyboardModifier value = qscriptvalue_cast<Qt::KeyboardModifier>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_KeyboardModifier_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::KeyboardModifier value = qscriptvalue_cast<Qt::KeyboardModifier>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_KeyboardModifier_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_KeyboardModifier_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_KeyboardModifier, + qtscript_Qt_KeyboardModifier_valueOf, qtscript_Qt_KeyboardModifier_toString); + qScriptRegisterMetaType<Qt::KeyboardModifier>(engine, qtscript_Qt_KeyboardModifier_toScriptValue, + qtscript_Qt_KeyboardModifier_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 8; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_KeyboardModifier_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_KeyboardModifier_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::KeyboardModifiers +// + +static QScriptValue qtscript_Qt_KeyboardModifiers_toScriptValue(QScriptEngine *engine, const Qt::KeyboardModifiers &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_KeyboardModifiers_fromScriptValue(const QScriptValue &value, Qt::KeyboardModifiers &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::KeyboardModifiers>()) + out = qvariant_cast<Qt::KeyboardModifiers>(var); + else if (var.userType() == qMetaTypeId<Qt::KeyboardModifier>()) + out = qvariant_cast<Qt::KeyboardModifier>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_KeyboardModifiers(QScriptContext *context, QScriptEngine *engine) +{ + Qt::KeyboardModifiers result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::KeyboardModifiers>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::KeyboardModifier>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("KeyboardModifiers(): argument %0 is not of type KeyboardModifier").arg(i)); + } + result |= qvariant_cast<Qt::KeyboardModifier>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_KeyboardModifiers_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::KeyboardModifiers value = qscriptvalue_cast<Qt::KeyboardModifiers>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_KeyboardModifiers_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::KeyboardModifiers value = qscriptvalue_cast<Qt::KeyboardModifiers>(context->thisObject()); + QString result; + for (int i = 0; i < 8; ++i) { + if ((value & qtscript_Qt_KeyboardModifier_values[i]) == qtscript_Qt_KeyboardModifier_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_KeyboardModifier_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_KeyboardModifiers_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::KeyboardModifiers>() == otherObj.value<Qt::KeyboardModifiers>()))); +} + +static QScriptValue qtscript_create_Qt_KeyboardModifiers_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_KeyboardModifiers, qtscript_Qt_KeyboardModifiers_valueOf, + qtscript_Qt_KeyboardModifiers_toString, qtscript_Qt_KeyboardModifiers_equals); + qScriptRegisterMetaType<Qt::KeyboardModifiers>(engine, qtscript_Qt_KeyboardModifiers_toScriptValue, + qtscript_Qt_KeyboardModifiers_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::WhiteSpaceMode +// + +static const Qt::WhiteSpaceMode qtscript_Qt_WhiteSpaceMode_values[] = { + Qt::WhiteSpaceModeUndefined + , Qt::WhiteSpaceNormal + , Qt::WhiteSpacePre + , Qt::WhiteSpaceNoWrap +}; + +static const char * const qtscript_Qt_WhiteSpaceMode_keys[] = { + "WhiteSpaceModeUndefined" + , "WhiteSpaceNormal" + , "WhiteSpacePre" + , "WhiteSpaceNoWrap" +}; + +static QString qtscript_Qt_WhiteSpaceMode_toStringHelper(Qt::WhiteSpaceMode value) +{ + if ((value >= Qt::WhiteSpaceModeUndefined) && (value <= Qt::WhiteSpaceNoWrap)) + return qtscript_Qt_WhiteSpaceMode_keys[static_cast<int>(value)-static_cast<int>(Qt::WhiteSpaceModeUndefined)]; + return QString(); +} + +static QScriptValue qtscript_Qt_WhiteSpaceMode_toScriptValue(QScriptEngine *engine, const Qt::WhiteSpaceMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WhiteSpaceMode_toStringHelper(value)); +} + +static void qtscript_Qt_WhiteSpaceMode_fromScriptValue(const QScriptValue &value, Qt::WhiteSpaceMode &out) +{ + out = qvariant_cast<Qt::WhiteSpaceMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WhiteSpaceMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::WhiteSpaceModeUndefined) && (arg <= Qt::WhiteSpaceNoWrap)) + return qScriptValueFromValue(engine, static_cast<Qt::WhiteSpaceMode>(arg)); + return context->throwError(QString::fromLatin1("WhiteSpaceMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WhiteSpaceMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WhiteSpaceMode value = qscriptvalue_cast<Qt::WhiteSpaceMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WhiteSpaceMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WhiteSpaceMode value = qscriptvalue_cast<Qt::WhiteSpaceMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WhiteSpaceMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WhiteSpaceMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WhiteSpaceMode, + qtscript_Qt_WhiteSpaceMode_valueOf, qtscript_Qt_WhiteSpaceMode_toString); + qScriptRegisterMetaType<Qt::WhiteSpaceMode>(engine, qtscript_Qt_WhiteSpaceMode_toScriptValue, + qtscript_Qt_WhiteSpaceMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WhiteSpaceMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WhiteSpaceMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DayOfWeek +// + +static const Qt::DayOfWeek qtscript_Qt_DayOfWeek_values[] = { + Qt::Monday + , Qt::Tuesday + , Qt::Wednesday + , Qt::Thursday + , Qt::Friday + , Qt::Saturday + , Qt::Sunday +}; + +static const char * const qtscript_Qt_DayOfWeek_keys[] = { + "Monday" + , "Tuesday" + , "Wednesday" + , "Thursday" + , "Friday" + , "Saturday" + , "Sunday" +}; + +static QString qtscript_Qt_DayOfWeek_toStringHelper(Qt::DayOfWeek value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DayOfWeek"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_DayOfWeek_toScriptValue(QScriptEngine *engine, const Qt::DayOfWeek &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_DayOfWeek_toStringHelper(value)); +} + +static void qtscript_Qt_DayOfWeek_fromScriptValue(const QScriptValue &value, Qt::DayOfWeek &out) +{ + out = qvariant_cast<Qt::DayOfWeek>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_DayOfWeek(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DayOfWeek"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::DayOfWeek>(arg)); + return context->throwError(QString::fromLatin1("DayOfWeek(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_DayOfWeek_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DayOfWeek value = qscriptvalue_cast<Qt::DayOfWeek>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DayOfWeek_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DayOfWeek value = qscriptvalue_cast<Qt::DayOfWeek>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_DayOfWeek_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_DayOfWeek_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_DayOfWeek, + qtscript_Qt_DayOfWeek_valueOf, qtscript_Qt_DayOfWeek_toString); + qScriptRegisterMetaType<Qt::DayOfWeek>(engine, qtscript_Qt_DayOfWeek_toScriptValue, + qtscript_Qt_DayOfWeek_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 7; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_DayOfWeek_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_DayOfWeek_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::EventPriority +// + +static const Qt::EventPriority qtscript_Qt_EventPriority_values[] = { + Qt::LowEventPriority + , Qt::NormalEventPriority + , Qt::HighEventPriority +}; + +static const char * const qtscript_Qt_EventPriority_keys[] = { + "LowEventPriority" + , "NormalEventPriority" + , "HighEventPriority" +}; + +static QString qtscript_Qt_EventPriority_toStringHelper(Qt::EventPriority value) +{ + if ((value >= Qt::LowEventPriority) && (value <= Qt::HighEventPriority)) + return qtscript_Qt_EventPriority_keys[static_cast<int>(value)-static_cast<int>(Qt::LowEventPriority)]; + return QString(); +} + +static QScriptValue qtscript_Qt_EventPriority_toScriptValue(QScriptEngine *engine, const Qt::EventPriority &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_EventPriority_toStringHelper(value)); +} + +static void qtscript_Qt_EventPriority_fromScriptValue(const QScriptValue &value, Qt::EventPriority &out) +{ + out = qvariant_cast<Qt::EventPriority>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_EventPriority(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::LowEventPriority) && (arg <= Qt::HighEventPriority)) + return qScriptValueFromValue(engine, static_cast<Qt::EventPriority>(arg)); + return context->throwError(QString::fromLatin1("EventPriority(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_EventPriority_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::EventPriority value = qscriptvalue_cast<Qt::EventPriority>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_EventPriority_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::EventPriority value = qscriptvalue_cast<Qt::EventPriority>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_EventPriority_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_EventPriority_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_EventPriority, + qtscript_Qt_EventPriority_valueOf, qtscript_Qt_EventPriority_toString); + qScriptRegisterMetaType<Qt::EventPriority>(engine, qtscript_Qt_EventPriority_toScriptValue, + qtscript_Qt_EventPriority_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_EventPriority_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_EventPriority_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DateFormat +// + +static const Qt::DateFormat qtscript_Qt_DateFormat_values[] = { + Qt::TextDate + , Qt::ISODate + , Qt::SystemLocaleDate + , Qt::LocaleDate + , Qt::SystemLocaleShortDate + , Qt::SystemLocaleLongDate + , Qt::DefaultLocaleShortDate + , Qt::DefaultLocaleLongDate +}; + +static const char * const qtscript_Qt_DateFormat_keys[] = { + "TextDate" + , "ISODate" + , "SystemLocaleDate" + , "LocaleDate" + , "SystemLocaleShortDate" + , "SystemLocaleLongDate" + , "DefaultLocaleShortDate" + , "DefaultLocaleLongDate" +}; + +static QString qtscript_Qt_DateFormat_toStringHelper(Qt::DateFormat value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DateFormat"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_DateFormat_toScriptValue(QScriptEngine *engine, const Qt::DateFormat &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_DateFormat_toStringHelper(value)); +} + +static void qtscript_Qt_DateFormat_fromScriptValue(const QScriptValue &value, Qt::DateFormat &out) +{ + out = qvariant_cast<Qt::DateFormat>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_DateFormat(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DateFormat"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::DateFormat>(arg)); + return context->throwError(QString::fromLatin1("DateFormat(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_DateFormat_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DateFormat value = qscriptvalue_cast<Qt::DateFormat>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DateFormat_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DateFormat value = qscriptvalue_cast<Qt::DateFormat>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_DateFormat_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_DateFormat_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_DateFormat, + qtscript_Qt_DateFormat_valueOf, qtscript_Qt_DateFormat_toString); + qScriptRegisterMetaType<Qt::DateFormat>(engine, qtscript_Qt_DateFormat_toScriptValue, + qtscript_Qt_DateFormat_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 8; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_DateFormat_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_DateFormat_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::MaskMode +// + +static const Qt::MaskMode qtscript_Qt_MaskMode_values[] = { + Qt::MaskInColor + , Qt::MaskOutColor +}; + +static const char * const qtscript_Qt_MaskMode_keys[] = { + "MaskInColor" + , "MaskOutColor" +}; + +static QString qtscript_Qt_MaskMode_toStringHelper(Qt::MaskMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("MaskMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_MaskMode_toScriptValue(QScriptEngine *engine, const Qt::MaskMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_MaskMode_toStringHelper(value)); +} + +static void qtscript_Qt_MaskMode_fromScriptValue(const QScriptValue &value, Qt::MaskMode &out) +{ + out = qvariant_cast<Qt::MaskMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_MaskMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("MaskMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::MaskMode>(arg)); + return context->throwError(QString::fromLatin1("MaskMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_MaskMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MaskMode value = qscriptvalue_cast<Qt::MaskMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_MaskMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MaskMode value = qscriptvalue_cast<Qt::MaskMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_MaskMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_MaskMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_MaskMode, + qtscript_Qt_MaskMode_valueOf, qtscript_Qt_MaskMode_toString); + qScriptRegisterMetaType<Qt::MaskMode>(engine, qtscript_Qt_MaskMode_toScriptValue, + qtscript_Qt_MaskMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_MaskMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_MaskMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::UIEffect +// + +static const Qt::UIEffect qtscript_Qt_UIEffect_values[] = { + Qt::UI_General + , Qt::UI_AnimateMenu + , Qt::UI_FadeMenu + , Qt::UI_AnimateCombo + , Qt::UI_AnimateTooltip + , Qt::UI_FadeTooltip + , Qt::UI_AnimateToolBox +}; + +static const char * const qtscript_Qt_UIEffect_keys[] = { + "UI_General" + , "UI_AnimateMenu" + , "UI_FadeMenu" + , "UI_AnimateCombo" + , "UI_AnimateTooltip" + , "UI_FadeTooltip" + , "UI_AnimateToolBox" +}; + +static QString qtscript_Qt_UIEffect_toStringHelper(Qt::UIEffect value) +{ + if ((value >= Qt::UI_General) && (value <= Qt::UI_AnimateToolBox)) + return qtscript_Qt_UIEffect_keys[static_cast<int>(value)-static_cast<int>(Qt::UI_General)]; + return QString(); +} + +static QScriptValue qtscript_Qt_UIEffect_toScriptValue(QScriptEngine *engine, const Qt::UIEffect &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_UIEffect_toStringHelper(value)); +} + +static void qtscript_Qt_UIEffect_fromScriptValue(const QScriptValue &value, Qt::UIEffect &out) +{ + out = qvariant_cast<Qt::UIEffect>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_UIEffect(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::UI_General) && (arg <= Qt::UI_AnimateToolBox)) + return qScriptValueFromValue(engine, static_cast<Qt::UIEffect>(arg)); + return context->throwError(QString::fromLatin1("UIEffect(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_UIEffect_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::UIEffect value = qscriptvalue_cast<Qt::UIEffect>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_UIEffect_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::UIEffect value = qscriptvalue_cast<Qt::UIEffect>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_UIEffect_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_UIEffect_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_UIEffect, + qtscript_Qt_UIEffect_valueOf, qtscript_Qt_UIEffect_toString); + qScriptRegisterMetaType<Qt::UIEffect>(engine, qtscript_Qt_UIEffect_toScriptValue, + qtscript_Qt_UIEffect_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 7; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_UIEffect_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_UIEffect_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ContextMenuPolicy +// + +static const Qt::ContextMenuPolicy qtscript_Qt_ContextMenuPolicy_values[] = { + Qt::NoContextMenu + , Qt::DefaultContextMenu + , Qt::ActionsContextMenu + , Qt::CustomContextMenu + , Qt::PreventContextMenu +}; + +static const char * const qtscript_Qt_ContextMenuPolicy_keys[] = { + "NoContextMenu" + , "DefaultContextMenu" + , "ActionsContextMenu" + , "CustomContextMenu" + , "PreventContextMenu" +}; + +static QString qtscript_Qt_ContextMenuPolicy_toStringHelper(Qt::ContextMenuPolicy value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ContextMenuPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ContextMenuPolicy_toScriptValue(QScriptEngine *engine, const Qt::ContextMenuPolicy &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ContextMenuPolicy_toStringHelper(value)); +} + +static void qtscript_Qt_ContextMenuPolicy_fromScriptValue(const QScriptValue &value, Qt::ContextMenuPolicy &out) +{ + out = qvariant_cast<Qt::ContextMenuPolicy>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ContextMenuPolicy(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ContextMenuPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ContextMenuPolicy>(arg)); + return context->throwError(QString::fromLatin1("ContextMenuPolicy(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ContextMenuPolicy_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ContextMenuPolicy value = qscriptvalue_cast<Qt::ContextMenuPolicy>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ContextMenuPolicy_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ContextMenuPolicy value = qscriptvalue_cast<Qt::ContextMenuPolicy>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ContextMenuPolicy_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ContextMenuPolicy_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ContextMenuPolicy, + qtscript_Qt_ContextMenuPolicy_valueOf, qtscript_Qt_ContextMenuPolicy_toString); + qScriptRegisterMetaType<Qt::ContextMenuPolicy>(engine, qtscript_Qt_ContextMenuPolicy_toScriptValue, + qtscript_Qt_ContextMenuPolicy_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ContextMenuPolicy_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ContextMenuPolicy_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::AnchorAttribute +// + +static const Qt::AnchorAttribute qtscript_Qt_AnchorAttribute_values[] = { + Qt::AnchorName + , Qt::AnchorHref +}; + +static const char * const qtscript_Qt_AnchorAttribute_keys[] = { + "AnchorName" + , "AnchorHref" +}; + +static QString qtscript_Qt_AnchorAttribute_toStringHelper(Qt::AnchorAttribute value) +{ + if ((value >= Qt::AnchorName) && (value <= Qt::AnchorHref)) + return qtscript_Qt_AnchorAttribute_keys[static_cast<int>(value)-static_cast<int>(Qt::AnchorName)]; + return QString(); +} + +static QScriptValue qtscript_Qt_AnchorAttribute_toScriptValue(QScriptEngine *engine, const Qt::AnchorAttribute &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_AnchorAttribute_toStringHelper(value)); +} + +static void qtscript_Qt_AnchorAttribute_fromScriptValue(const QScriptValue &value, Qt::AnchorAttribute &out) +{ + out = qvariant_cast<Qt::AnchorAttribute>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_AnchorAttribute(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::AnchorName) && (arg <= Qt::AnchorHref)) + return qScriptValueFromValue(engine, static_cast<Qt::AnchorAttribute>(arg)); + return context->throwError(QString::fromLatin1("AnchorAttribute(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_AnchorAttribute_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AnchorAttribute value = qscriptvalue_cast<Qt::AnchorAttribute>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_AnchorAttribute_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AnchorAttribute value = qscriptvalue_cast<Qt::AnchorAttribute>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_AnchorAttribute_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_AnchorAttribute_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_AnchorAttribute, + qtscript_Qt_AnchorAttribute_valueOf, qtscript_Qt_AnchorAttribute_toString); + qScriptRegisterMetaType<Qt::AnchorAttribute>(engine, qtscript_Qt_AnchorAttribute_toScriptValue, + qtscript_Qt_AnchorAttribute_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_AnchorAttribute_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_AnchorAttribute_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ScrollBarPolicy +// + +static const Qt::ScrollBarPolicy qtscript_Qt_ScrollBarPolicy_values[] = { + Qt::ScrollBarAsNeeded + , Qt::ScrollBarAlwaysOff + , Qt::ScrollBarAlwaysOn +}; + +static const char * const qtscript_Qt_ScrollBarPolicy_keys[] = { + "ScrollBarAsNeeded" + , "ScrollBarAlwaysOff" + , "ScrollBarAlwaysOn" +}; + +static QString qtscript_Qt_ScrollBarPolicy_toStringHelper(Qt::ScrollBarPolicy value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ScrollBarPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ScrollBarPolicy_toScriptValue(QScriptEngine *engine, const Qt::ScrollBarPolicy &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ScrollBarPolicy_toStringHelper(value)); +} + +static void qtscript_Qt_ScrollBarPolicy_fromScriptValue(const QScriptValue &value, Qt::ScrollBarPolicy &out) +{ + out = qvariant_cast<Qt::ScrollBarPolicy>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ScrollBarPolicy(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ScrollBarPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ScrollBarPolicy>(arg)); + return context->throwError(QString::fromLatin1("ScrollBarPolicy(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ScrollBarPolicy_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ScrollBarPolicy value = qscriptvalue_cast<Qt::ScrollBarPolicy>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ScrollBarPolicy_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ScrollBarPolicy value = qscriptvalue_cast<Qt::ScrollBarPolicy>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ScrollBarPolicy_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ScrollBarPolicy_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ScrollBarPolicy, + qtscript_Qt_ScrollBarPolicy_valueOf, qtscript_Qt_ScrollBarPolicy_toString); + qScriptRegisterMetaType<Qt::ScrollBarPolicy>(engine, qtscript_Qt_ScrollBarPolicy_toScriptValue, + qtscript_Qt_ScrollBarPolicy_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ScrollBarPolicy_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ScrollBarPolicy_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ToolButtonStyle +// + +static const Qt::ToolButtonStyle qtscript_Qt_ToolButtonStyle_values[] = { + Qt::ToolButtonIconOnly + , Qt::ToolButtonTextOnly + , Qt::ToolButtonTextBesideIcon + , Qt::ToolButtonTextUnderIcon +}; + +static const char * const qtscript_Qt_ToolButtonStyle_keys[] = { + "ToolButtonIconOnly" + , "ToolButtonTextOnly" + , "ToolButtonTextBesideIcon" + , "ToolButtonTextUnderIcon" +}; + +static QString qtscript_Qt_ToolButtonStyle_toStringHelper(Qt::ToolButtonStyle value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ToolButtonStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ToolButtonStyle_toScriptValue(QScriptEngine *engine, const Qt::ToolButtonStyle &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ToolButtonStyle_toStringHelper(value)); +} + +static void qtscript_Qt_ToolButtonStyle_fromScriptValue(const QScriptValue &value, Qt::ToolButtonStyle &out) +{ + out = qvariant_cast<Qt::ToolButtonStyle>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ToolButtonStyle(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ToolButtonStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ToolButtonStyle>(arg)); + return context->throwError(QString::fromLatin1("ToolButtonStyle(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ToolButtonStyle_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolButtonStyle value = qscriptvalue_cast<Qt::ToolButtonStyle>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ToolButtonStyle_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolButtonStyle value = qscriptvalue_cast<Qt::ToolButtonStyle>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ToolButtonStyle_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ToolButtonStyle_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ToolButtonStyle, + qtscript_Qt_ToolButtonStyle_valueOf, qtscript_Qt_ToolButtonStyle_toString); + qScriptRegisterMetaType<Qt::ToolButtonStyle>(engine, qtscript_Qt_ToolButtonStyle_toScriptValue, + qtscript_Qt_ToolButtonStyle_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ToolButtonStyle_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ToolButtonStyle_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TextFlag +// + +static const Qt::TextFlag qtscript_Qt_TextFlag_values[] = { + Qt::TextSingleLine + , Qt::TextDontClip + , Qt::TextExpandTabs + , Qt::TextShowMnemonic + , Qt::TextWordWrap + , Qt::TextWrapAnywhere + , Qt::TextDontPrint + , Qt::TextHideMnemonic + , Qt::TextJustificationForced + , Qt::TextForceLeftToRight + , Qt::TextForceRightToLeft + , Qt::TextIncludeTrailingSpaces +}; + +static const char * const qtscript_Qt_TextFlag_keys[] = { + "TextSingleLine" + , "TextDontClip" + , "TextExpandTabs" + , "TextShowMnemonic" + , "TextWordWrap" + , "TextWrapAnywhere" + , "TextDontPrint" + , "TextHideMnemonic" + , "TextJustificationForced" + , "TextForceLeftToRight" + , "TextForceRightToLeft" + , "TextIncludeTrailingSpaces" +}; + +static QString qtscript_Qt_TextFlag_toStringHelper(Qt::TextFlag value) +{ + for (int i = 0; i < 12; ++i) { + if (qtscript_Qt_TextFlag_values[i] == value) + return QString::fromLatin1(qtscript_Qt_TextFlag_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_TextFlag_toScriptValue(QScriptEngine *engine, const Qt::TextFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TextFlag_toStringHelper(value)); +} + +static void qtscript_Qt_TextFlag_fromScriptValue(const QScriptValue &value, Qt::TextFlag &out) +{ + out = qvariant_cast<Qt::TextFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TextFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 12; ++i) { + if (qtscript_Qt_TextFlag_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::TextFlag>(arg)); + } + return context->throwError(QString::fromLatin1("TextFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TextFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextFlag value = qscriptvalue_cast<Qt::TextFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TextFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextFlag value = qscriptvalue_cast<Qt::TextFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TextFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TextFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TextFlag, + qtscript_Qt_TextFlag_valueOf, qtscript_Qt_TextFlag_toString); + qScriptRegisterMetaType<Qt::TextFlag>(engine, qtscript_Qt_TextFlag_toScriptValue, + qtscript_Qt_TextFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 12; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TextFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TextFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ItemSelectionMode +// + +static const Qt::ItemSelectionMode qtscript_Qt_ItemSelectionMode_values[] = { + Qt::ContainsItemShape + , Qt::IntersectsItemShape + , Qt::ContainsItemBoundingRect + , Qt::IntersectsItemBoundingRect +}; + +static const char * const qtscript_Qt_ItemSelectionMode_keys[] = { + "ContainsItemShape" + , "IntersectsItemShape" + , "ContainsItemBoundingRect" + , "IntersectsItemBoundingRect" +}; + +static QString qtscript_Qt_ItemSelectionMode_toStringHelper(Qt::ItemSelectionMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ItemSelectionMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ItemSelectionMode_toScriptValue(QScriptEngine *engine, const Qt::ItemSelectionMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ItemSelectionMode_toStringHelper(value)); +} + +static void qtscript_Qt_ItemSelectionMode_fromScriptValue(const QScriptValue &value, Qt::ItemSelectionMode &out) +{ + out = qvariant_cast<Qt::ItemSelectionMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ItemSelectionMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ItemSelectionMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ItemSelectionMode>(arg)); + return context->throwError(QString::fromLatin1("ItemSelectionMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ItemSelectionMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemSelectionMode value = qscriptvalue_cast<Qt::ItemSelectionMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ItemSelectionMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemSelectionMode value = qscriptvalue_cast<Qt::ItemSelectionMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ItemSelectionMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ItemSelectionMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ItemSelectionMode, + qtscript_Qt_ItemSelectionMode_valueOf, qtscript_Qt_ItemSelectionMode_toString); + qScriptRegisterMetaType<Qt::ItemSelectionMode>(engine, qtscript_Qt_ItemSelectionMode_toScriptValue, + qtscript_Qt_ItemSelectionMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ItemSelectionMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ItemSelectionMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::SizeHint +// + +static const Qt::SizeHint qtscript_Qt_SizeHint_values[] = { + Qt::MinimumSize + , Qt::PreferredSize + , Qt::MaximumSize + , Qt::MinimumDescent + , Qt::NSizeHints +}; + +static const char * const qtscript_Qt_SizeHint_keys[] = { + "MinimumSize" + , "PreferredSize" + , "MaximumSize" + , "MinimumDescent" + , "NSizeHints" +}; + +static QString qtscript_Qt_SizeHint_toStringHelper(Qt::SizeHint value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SizeHint"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_SizeHint_toScriptValue(QScriptEngine *engine, const Qt::SizeHint &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_SizeHint_toStringHelper(value)); +} + +static void qtscript_Qt_SizeHint_fromScriptValue(const QScriptValue &value, Qt::SizeHint &out) +{ + out = qvariant_cast<Qt::SizeHint>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_SizeHint(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("SizeHint"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::SizeHint>(arg)); + return context->throwError(QString::fromLatin1("SizeHint(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_SizeHint_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SizeHint value = qscriptvalue_cast<Qt::SizeHint>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_SizeHint_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::SizeHint value = qscriptvalue_cast<Qt::SizeHint>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_SizeHint_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_SizeHint_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_SizeHint, + qtscript_Qt_SizeHint_valueOf, qtscript_Qt_SizeHint_toString); + qScriptRegisterMetaType<Qt::SizeHint>(engine, qtscript_Qt_SizeHint_toScriptValue, + qtscript_Qt_SizeHint_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_SizeHint_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_SizeHint_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Key +// + +static const Qt::Key qtscript_Qt_Key_values[] = { + Qt::Key_Space + , Qt::Key_Exclam + , Qt::Key_QuoteDbl + , Qt::Key_NumberSign + , Qt::Key_Dollar + , Qt::Key_Percent + , Qt::Key_Ampersand + , Qt::Key_Apostrophe + , Qt::Key_ParenLeft + , Qt::Key_ParenRight + , Qt::Key_Asterisk + , Qt::Key_Plus + , Qt::Key_Comma + , Qt::Key_Minus + , Qt::Key_Period + , Qt::Key_Slash + , Qt::Key_0 + , Qt::Key_1 + , Qt::Key_2 + , Qt::Key_3 + , Qt::Key_4 + , Qt::Key_5 + , Qt::Key_6 + , Qt::Key_7 + , Qt::Key_8 + , Qt::Key_9 + , Qt::Key_Colon + , Qt::Key_Semicolon + , Qt::Key_Less + , Qt::Key_Equal + , Qt::Key_Greater + , Qt::Key_Question + , Qt::Key_At + , Qt::Key_A + , Qt::Key_B + , Qt::Key_C + , Qt::Key_D + , Qt::Key_E + , Qt::Key_F + , Qt::Key_G + , Qt::Key_H + , Qt::Key_I + , Qt::Key_J + , Qt::Key_K + , Qt::Key_L + , Qt::Key_M + , Qt::Key_N + , Qt::Key_O + , Qt::Key_P + , Qt::Key_Q + , Qt::Key_R + , Qt::Key_S + , Qt::Key_T + , Qt::Key_U + , Qt::Key_V + , Qt::Key_W + , Qt::Key_X + , Qt::Key_Y + , Qt::Key_Z + , Qt::Key_BracketLeft + , Qt::Key_Backslash + , Qt::Key_BracketRight + , Qt::Key_AsciiCircum + , Qt::Key_Underscore + , Qt::Key_QuoteLeft + , Qt::Key_BraceLeft + , Qt::Key_Bar + , Qt::Key_BraceRight + , Qt::Key_AsciiTilde + , Qt::Key_nobreakspace + , Qt::Key_exclamdown + , Qt::Key_cent + , Qt::Key_sterling + , Qt::Key_currency + , Qt::Key_yen + , Qt::Key_brokenbar + , Qt::Key_section + , Qt::Key_diaeresis + , Qt::Key_copyright + , Qt::Key_ordfeminine + , Qt::Key_guillemotleft + , Qt::Key_notsign + , Qt::Key_hyphen + , Qt::Key_registered + , Qt::Key_macron + , Qt::Key_degree + , Qt::Key_plusminus + , Qt::Key_twosuperior + , Qt::Key_threesuperior + , Qt::Key_acute + , Qt::Key_mu + , Qt::Key_paragraph + , Qt::Key_periodcentered + , Qt::Key_cedilla + , Qt::Key_onesuperior + , Qt::Key_masculine + , Qt::Key_guillemotright + , Qt::Key_onequarter + , Qt::Key_onehalf + , Qt::Key_threequarters + , Qt::Key_questiondown + , Qt::Key_Agrave + , Qt::Key_Aacute + , Qt::Key_Acircumflex + , Qt::Key_Atilde + , Qt::Key_Adiaeresis + , Qt::Key_Aring + , Qt::Key_AE + , Qt::Key_Ccedilla + , Qt::Key_Egrave + , Qt::Key_Eacute + , Qt::Key_Ecircumflex + , Qt::Key_Ediaeresis + , Qt::Key_Igrave + , Qt::Key_Iacute + , Qt::Key_Icircumflex + , Qt::Key_Idiaeresis + , Qt::Key_ETH + , Qt::Key_Ntilde + , Qt::Key_Ograve + , Qt::Key_Oacute + , Qt::Key_Ocircumflex + , Qt::Key_Otilde + , Qt::Key_Odiaeresis + , Qt::Key_multiply + , Qt::Key_Ooblique + , Qt::Key_Ugrave + , Qt::Key_Uacute + , Qt::Key_Ucircumflex + , Qt::Key_Udiaeresis + , Qt::Key_Yacute + , Qt::Key_THORN + , Qt::Key_ssharp + , Qt::Key_division + , Qt::Key_ydiaeresis + , Qt::Key_Escape + , Qt::Key_Tab + , Qt::Key_Backtab + , Qt::Key_Backspace + , Qt::Key_Return + , Qt::Key_Enter + , Qt::Key_Insert + , Qt::Key_Delete + , Qt::Key_Pause + , Qt::Key_Print + , Qt::Key_SysReq + , Qt::Key_Clear + , Qt::Key_Home + , Qt::Key_End + , Qt::Key_Left + , Qt::Key_Up + , Qt::Key_Right + , Qt::Key_Down + , Qt::Key_PageUp + , Qt::Key_PageDown + , Qt::Key_Shift + , Qt::Key_Control + , Qt::Key_Meta + , Qt::Key_Alt + , Qt::Key_CapsLock + , Qt::Key_NumLock + , Qt::Key_ScrollLock + , Qt::Key_F1 + , Qt::Key_F2 + , Qt::Key_F3 + , Qt::Key_F4 + , Qt::Key_F5 + , Qt::Key_F6 + , Qt::Key_F7 + , Qt::Key_F8 + , Qt::Key_F9 + , Qt::Key_F10 + , Qt::Key_F11 + , Qt::Key_F12 + , Qt::Key_F13 + , Qt::Key_F14 + , Qt::Key_F15 + , Qt::Key_F16 + , Qt::Key_F17 + , Qt::Key_F18 + , Qt::Key_F19 + , Qt::Key_F20 + , Qt::Key_F21 + , Qt::Key_F22 + , Qt::Key_F23 + , Qt::Key_F24 + , Qt::Key_F25 + , Qt::Key_F26 + , Qt::Key_F27 + , Qt::Key_F28 + , Qt::Key_F29 + , Qt::Key_F30 + , Qt::Key_F31 + , Qt::Key_F32 + , Qt::Key_F33 + , Qt::Key_F34 + , Qt::Key_F35 + , Qt::Key_Super_L + , Qt::Key_Super_R + , Qt::Key_Menu + , Qt::Key_Hyper_L + , Qt::Key_Hyper_R + , Qt::Key_Help + , Qt::Key_Direction_L + , Qt::Key_Direction_R + , Qt::Key_Back + , Qt::Key_Forward + , Qt::Key_Stop + , Qt::Key_Refresh + , Qt::Key_VolumeDown + , Qt::Key_VolumeMute + , Qt::Key_VolumeUp + , Qt::Key_BassBoost + , Qt::Key_BassUp + , Qt::Key_BassDown + , Qt::Key_TrebleUp + , Qt::Key_TrebleDown + , Qt::Key_MediaPlay + , Qt::Key_MediaStop + , Qt::Key_MediaPrevious + , Qt::Key_MediaNext + , Qt::Key_MediaRecord + , Qt::Key_HomePage + , Qt::Key_Favorites + , Qt::Key_Search + , Qt::Key_Standby + , Qt::Key_OpenUrl + , Qt::Key_LaunchMail + , Qt::Key_LaunchMedia + , Qt::Key_Launch0 + , Qt::Key_Launch1 + , Qt::Key_Launch2 + , Qt::Key_Launch3 + , Qt::Key_Launch4 + , Qt::Key_Launch5 + , Qt::Key_Launch6 + , Qt::Key_Launch7 + , Qt::Key_Launch8 + , Qt::Key_Launch9 + , Qt::Key_LaunchA + , Qt::Key_LaunchB + , Qt::Key_LaunchC + , Qt::Key_LaunchD + , Qt::Key_LaunchE + , Qt::Key_LaunchF + , Qt::Key_AltGr + , Qt::Key_Multi_key + , Qt::Key_Kanji + , Qt::Key_Muhenkan + , Qt::Key_Henkan + , Qt::Key_Romaji + , Qt::Key_Hiragana + , Qt::Key_Katakana + , Qt::Key_Hiragana_Katakana + , Qt::Key_Zenkaku + , Qt::Key_Hankaku + , Qt::Key_Zenkaku_Hankaku + , Qt::Key_Touroku + , Qt::Key_Massyo + , Qt::Key_Kana_Lock + , Qt::Key_Kana_Shift + , Qt::Key_Eisu_Shift + , Qt::Key_Eisu_toggle + , Qt::Key_Hangul + , Qt::Key_Hangul_Start + , Qt::Key_Hangul_End + , Qt::Key_Hangul_Hanja + , Qt::Key_Hangul_Jamo + , Qt::Key_Hangul_Romaja + , Qt::Key_Codeinput + , Qt::Key_Hangul_Jeonja + , Qt::Key_Hangul_Banja + , Qt::Key_Hangul_PreHanja + , Qt::Key_Hangul_PostHanja + , Qt::Key_SingleCandidate + , Qt::Key_MultipleCandidate + , Qt::Key_PreviousCandidate + , Qt::Key_Hangul_Special + , Qt::Key_Mode_switch + , Qt::Key_Dead_Grave + , Qt::Key_Dead_Acute + , Qt::Key_Dead_Circumflex + , Qt::Key_Dead_Tilde + , Qt::Key_Dead_Macron + , Qt::Key_Dead_Breve + , Qt::Key_Dead_Abovedot + , Qt::Key_Dead_Diaeresis + , Qt::Key_Dead_Abovering + , Qt::Key_Dead_Doubleacute + , Qt::Key_Dead_Caron + , Qt::Key_Dead_Cedilla + , Qt::Key_Dead_Ogonek + , Qt::Key_Dead_Iota + , Qt::Key_Dead_Voiced_Sound + , Qt::Key_Dead_Semivoiced_Sound + , Qt::Key_Dead_Belowdot + , Qt::Key_Dead_Hook + , Qt::Key_Dead_Horn + , Qt::Key_MediaLast + , Qt::Key_Select + , Qt::Key_Yes + , Qt::Key_No + , Qt::Key_Cancel + , Qt::Key_Printer + , Qt::Key_Execute + , Qt::Key_Sleep + , Qt::Key_Play + , Qt::Key_Zoom + , Qt::Key_Context1 + , Qt::Key_Context2 + , Qt::Key_Context3 + , Qt::Key_Context4 + , Qt::Key_Call + , Qt::Key_Hangup + , Qt::Key_Flip + , Qt::Key_unknown +}; + +static const char * const qtscript_Qt_Key_keys[] = { + "Key_Space" + , "Key_Exclam" + , "Key_QuoteDbl" + , "Key_NumberSign" + , "Key_Dollar" + , "Key_Percent" + , "Key_Ampersand" + , "Key_Apostrophe" + , "Key_ParenLeft" + , "Key_ParenRight" + , "Key_Asterisk" + , "Key_Plus" + , "Key_Comma" + , "Key_Minus" + , "Key_Period" + , "Key_Slash" + , "Key_0" + , "Key_1" + , "Key_2" + , "Key_3" + , "Key_4" + , "Key_5" + , "Key_6" + , "Key_7" + , "Key_8" + , "Key_9" + , "Key_Colon" + , "Key_Semicolon" + , "Key_Less" + , "Key_Equal" + , "Key_Greater" + , "Key_Question" + , "Key_At" + , "Key_A" + , "Key_B" + , "Key_C" + , "Key_D" + , "Key_E" + , "Key_F" + , "Key_G" + , "Key_H" + , "Key_I" + , "Key_J" + , "Key_K" + , "Key_L" + , "Key_M" + , "Key_N" + , "Key_O" + , "Key_P" + , "Key_Q" + , "Key_R" + , "Key_S" + , "Key_T" + , "Key_U" + , "Key_V" + , "Key_W" + , "Key_X" + , "Key_Y" + , "Key_Z" + , "Key_BracketLeft" + , "Key_Backslash" + , "Key_BracketRight" + , "Key_AsciiCircum" + , "Key_Underscore" + , "Key_QuoteLeft" + , "Key_BraceLeft" + , "Key_Bar" + , "Key_BraceRight" + , "Key_AsciiTilde" + , "Key_nobreakspace" + , "Key_exclamdown" + , "Key_cent" + , "Key_sterling" + , "Key_currency" + , "Key_yen" + , "Key_brokenbar" + , "Key_section" + , "Key_diaeresis" + , "Key_copyright" + , "Key_ordfeminine" + , "Key_guillemotleft" + , "Key_notsign" + , "Key_hyphen" + , "Key_registered" + , "Key_macron" + , "Key_degree" + , "Key_plusminus" + , "Key_twosuperior" + , "Key_threesuperior" + , "Key_acute" + , "Key_mu" + , "Key_paragraph" + , "Key_periodcentered" + , "Key_cedilla" + , "Key_onesuperior" + , "Key_masculine" + , "Key_guillemotright" + , "Key_onequarter" + , "Key_onehalf" + , "Key_threequarters" + , "Key_questiondown" + , "Key_Agrave" + , "Key_Aacute" + , "Key_Acircumflex" + , "Key_Atilde" + , "Key_Adiaeresis" + , "Key_Aring" + , "Key_AE" + , "Key_Ccedilla" + , "Key_Egrave" + , "Key_Eacute" + , "Key_Ecircumflex" + , "Key_Ediaeresis" + , "Key_Igrave" + , "Key_Iacute" + , "Key_Icircumflex" + , "Key_Idiaeresis" + , "Key_ETH" + , "Key_Ntilde" + , "Key_Ograve" + , "Key_Oacute" + , "Key_Ocircumflex" + , "Key_Otilde" + , "Key_Odiaeresis" + , "Key_multiply" + , "Key_Ooblique" + , "Key_Ugrave" + , "Key_Uacute" + , "Key_Ucircumflex" + , "Key_Udiaeresis" + , "Key_Yacute" + , "Key_THORN" + , "Key_ssharp" + , "Key_division" + , "Key_ydiaeresis" + , "Key_Escape" + , "Key_Tab" + , "Key_Backtab" + , "Key_Backspace" + , "Key_Return" + , "Key_Enter" + , "Key_Insert" + , "Key_Delete" + , "Key_Pause" + , "Key_Print" + , "Key_SysReq" + , "Key_Clear" + , "Key_Home" + , "Key_End" + , "Key_Left" + , "Key_Up" + , "Key_Right" + , "Key_Down" + , "Key_PageUp" + , "Key_PageDown" + , "Key_Shift" + , "Key_Control" + , "Key_Meta" + , "Key_Alt" + , "Key_CapsLock" + , "Key_NumLock" + , "Key_ScrollLock" + , "Key_F1" + , "Key_F2" + , "Key_F3" + , "Key_F4" + , "Key_F5" + , "Key_F6" + , "Key_F7" + , "Key_F8" + , "Key_F9" + , "Key_F10" + , "Key_F11" + , "Key_F12" + , "Key_F13" + , "Key_F14" + , "Key_F15" + , "Key_F16" + , "Key_F17" + , "Key_F18" + , "Key_F19" + , "Key_F20" + , "Key_F21" + , "Key_F22" + , "Key_F23" + , "Key_F24" + , "Key_F25" + , "Key_F26" + , "Key_F27" + , "Key_F28" + , "Key_F29" + , "Key_F30" + , "Key_F31" + , "Key_F32" + , "Key_F33" + , "Key_F34" + , "Key_F35" + , "Key_Super_L" + , "Key_Super_R" + , "Key_Menu" + , "Key_Hyper_L" + , "Key_Hyper_R" + , "Key_Help" + , "Key_Direction_L" + , "Key_Direction_R" + , "Key_Back" + , "Key_Forward" + , "Key_Stop" + , "Key_Refresh" + , "Key_VolumeDown" + , "Key_VolumeMute" + , "Key_VolumeUp" + , "Key_BassBoost" + , "Key_BassUp" + , "Key_BassDown" + , "Key_TrebleUp" + , "Key_TrebleDown" + , "Key_MediaPlay" + , "Key_MediaStop" + , "Key_MediaPrevious" + , "Key_MediaNext" + , "Key_MediaRecord" + , "Key_HomePage" + , "Key_Favorites" + , "Key_Search" + , "Key_Standby" + , "Key_OpenUrl" + , "Key_LaunchMail" + , "Key_LaunchMedia" + , "Key_Launch0" + , "Key_Launch1" + , "Key_Launch2" + , "Key_Launch3" + , "Key_Launch4" + , "Key_Launch5" + , "Key_Launch6" + , "Key_Launch7" + , "Key_Launch8" + , "Key_Launch9" + , "Key_LaunchA" + , "Key_LaunchB" + , "Key_LaunchC" + , "Key_LaunchD" + , "Key_LaunchE" + , "Key_LaunchF" + , "Key_AltGr" + , "Key_Multi_key" + , "Key_Kanji" + , "Key_Muhenkan" + , "Key_Henkan" + , "Key_Romaji" + , "Key_Hiragana" + , "Key_Katakana" + , "Key_Hiragana_Katakana" + , "Key_Zenkaku" + , "Key_Hankaku" + , "Key_Zenkaku_Hankaku" + , "Key_Touroku" + , "Key_Massyo" + , "Key_Kana_Lock" + , "Key_Kana_Shift" + , "Key_Eisu_Shift" + , "Key_Eisu_toggle" + , "Key_Hangul" + , "Key_Hangul_Start" + , "Key_Hangul_End" + , "Key_Hangul_Hanja" + , "Key_Hangul_Jamo" + , "Key_Hangul_Romaja" + , "Key_Codeinput" + , "Key_Hangul_Jeonja" + , "Key_Hangul_Banja" + , "Key_Hangul_PreHanja" + , "Key_Hangul_PostHanja" + , "Key_SingleCandidate" + , "Key_MultipleCandidate" + , "Key_PreviousCandidate" + , "Key_Hangul_Special" + , "Key_Mode_switch" + , "Key_Dead_Grave" + , "Key_Dead_Acute" + , "Key_Dead_Circumflex" + , "Key_Dead_Tilde" + , "Key_Dead_Macron" + , "Key_Dead_Breve" + , "Key_Dead_Abovedot" + , "Key_Dead_Diaeresis" + , "Key_Dead_Abovering" + , "Key_Dead_Doubleacute" + , "Key_Dead_Caron" + , "Key_Dead_Cedilla" + , "Key_Dead_Ogonek" + , "Key_Dead_Iota" + , "Key_Dead_Voiced_Sound" + , "Key_Dead_Semivoiced_Sound" + , "Key_Dead_Belowdot" + , "Key_Dead_Hook" + , "Key_Dead_Horn" + , "Key_MediaLast" + , "Key_Select" + , "Key_Yes" + , "Key_No" + , "Key_Cancel" + , "Key_Printer" + , "Key_Execute" + , "Key_Sleep" + , "Key_Play" + , "Key_Zoom" + , "Key_Context1" + , "Key_Context2" + , "Key_Context3" + , "Key_Context4" + , "Key_Call" + , "Key_Hangup" + , "Key_Flip" + , "Key_unknown" +}; + +static QString qtscript_Qt_Key_toStringHelper(Qt::Key value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Key"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_Key_toScriptValue(QScriptEngine *engine, const Qt::Key &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_Key_toStringHelper(value)); +} + +static void qtscript_Qt_Key_fromScriptValue(const QScriptValue &value, Qt::Key &out) +{ + out = qvariant_cast<Qt::Key>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_Key(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("Key"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::Key>(arg)); + return context->throwError(QString::fromLatin1("Key(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_Key_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Key value = qscriptvalue_cast<Qt::Key>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Key_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Key value = qscriptvalue_cast<Qt::Key>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_Key_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_Key_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_Key, + qtscript_Qt_Key_valueOf, qtscript_Qt_Key_toString); + qScriptRegisterMetaType<Qt::Key>(engine, qtscript_Qt_Key_toScriptValue, + qtscript_Qt_Key_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 316; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_Key_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_Key_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ToolBarAreaSizes +// + +static const Qt::ToolBarAreaSizes qtscript_Qt_ToolBarAreaSizes_values[] = { + Qt::NToolBarAreas +}; + +static const char * const qtscript_Qt_ToolBarAreaSizes_keys[] = { + "NToolBarAreas" +}; + +static QString qtscript_Qt_ToolBarAreaSizes_toStringHelper(Qt::ToolBarAreaSizes value) +{ + if ((value >= Qt::NToolBarAreas) && (value <= Qt::NToolBarAreas)) + return qtscript_Qt_ToolBarAreaSizes_keys[static_cast<int>(value)-static_cast<int>(Qt::NToolBarAreas)]; + return QString(); +} + +static QScriptValue qtscript_Qt_ToolBarAreaSizes_toScriptValue(QScriptEngine *engine, const Qt::ToolBarAreaSizes &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ToolBarAreaSizes_toStringHelper(value)); +} + +static void qtscript_Qt_ToolBarAreaSizes_fromScriptValue(const QScriptValue &value, Qt::ToolBarAreaSizes &out) +{ + out = qvariant_cast<Qt::ToolBarAreaSizes>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ToolBarAreaSizes(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::NToolBarAreas) && (arg <= Qt::NToolBarAreas)) + return qScriptValueFromValue(engine, static_cast<Qt::ToolBarAreaSizes>(arg)); + return context->throwError(QString::fromLatin1("ToolBarAreaSizes(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ToolBarAreaSizes_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarAreaSizes value = qscriptvalue_cast<Qt::ToolBarAreaSizes>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ToolBarAreaSizes_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ToolBarAreaSizes value = qscriptvalue_cast<Qt::ToolBarAreaSizes>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ToolBarAreaSizes_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ToolBarAreaSizes_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ToolBarAreaSizes, + qtscript_Qt_ToolBarAreaSizes_valueOf, qtscript_Qt_ToolBarAreaSizes_toString); + qScriptRegisterMetaType<Qt::ToolBarAreaSizes>(engine, qtscript_Qt_ToolBarAreaSizes_toScriptValue, + qtscript_Qt_ToolBarAreaSizes_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 1; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ToolBarAreaSizes_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ToolBarAreaSizes_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ArrowType +// + +static const Qt::ArrowType qtscript_Qt_ArrowType_values[] = { + Qt::NoArrow + , Qt::UpArrow + , Qt::DownArrow + , Qt::LeftArrow + , Qt::RightArrow +}; + +static const char * const qtscript_Qt_ArrowType_keys[] = { + "NoArrow" + , "UpArrow" + , "DownArrow" + , "LeftArrow" + , "RightArrow" +}; + +static QString qtscript_Qt_ArrowType_toStringHelper(Qt::ArrowType value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ArrowType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ArrowType_toScriptValue(QScriptEngine *engine, const Qt::ArrowType &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ArrowType_toStringHelper(value)); +} + +static void qtscript_Qt_ArrowType_fromScriptValue(const QScriptValue &value, Qt::ArrowType &out) +{ + out = qvariant_cast<Qt::ArrowType>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ArrowType(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ArrowType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ArrowType>(arg)); + return context->throwError(QString::fromLatin1("ArrowType(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ArrowType_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ArrowType value = qscriptvalue_cast<Qt::ArrowType>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ArrowType_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ArrowType value = qscriptvalue_cast<Qt::ArrowType>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ArrowType_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ArrowType_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ArrowType, + qtscript_Qt_ArrowType_valueOf, qtscript_Qt_ArrowType_toString); + qScriptRegisterMetaType<Qt::ArrowType>(engine, qtscript_Qt_ArrowType_toScriptValue, + qtscript_Qt_ArrowType_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ArrowType_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ArrowType_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::FocusPolicy +// + +static const Qt::FocusPolicy qtscript_Qt_FocusPolicy_values[] = { + Qt::NoFocus + , Qt::TabFocus + , Qt::ClickFocus + , Qt::StrongFocus + , Qt::WheelFocus +}; + +static const char * const qtscript_Qt_FocusPolicy_keys[] = { + "NoFocus" + , "TabFocus" + , "ClickFocus" + , "StrongFocus" + , "WheelFocus" +}; + +static QString qtscript_Qt_FocusPolicy_toStringHelper(Qt::FocusPolicy value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("FocusPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_FocusPolicy_toScriptValue(QScriptEngine *engine, const Qt::FocusPolicy &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_FocusPolicy_toStringHelper(value)); +} + +static void qtscript_Qt_FocusPolicy_fromScriptValue(const QScriptValue &value, Qt::FocusPolicy &out) +{ + out = qvariant_cast<Qt::FocusPolicy>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_FocusPolicy(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("FocusPolicy"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::FocusPolicy>(arg)); + return context->throwError(QString::fromLatin1("FocusPolicy(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_FocusPolicy_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FocusPolicy value = qscriptvalue_cast<Qt::FocusPolicy>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_FocusPolicy_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FocusPolicy value = qscriptvalue_cast<Qt::FocusPolicy>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_FocusPolicy_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_FocusPolicy_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_FocusPolicy, + qtscript_Qt_FocusPolicy_valueOf, qtscript_Qt_FocusPolicy_toString); + qScriptRegisterMetaType<Qt::FocusPolicy>(engine, qtscript_Qt_FocusPolicy_toScriptValue, + qtscript_Qt_FocusPolicy_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_FocusPolicy_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_FocusPolicy_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::WindowFrameSection +// + +static const Qt::WindowFrameSection qtscript_Qt_WindowFrameSection_values[] = { + Qt::NoSection + , Qt::LeftSection + , Qt::TopLeftSection + , Qt::TopSection + , Qt::TopRightSection + , Qt::RightSection + , Qt::BottomRightSection + , Qt::BottomSection + , Qt::BottomLeftSection + , Qt::TitleBarArea +}; + +static const char * const qtscript_Qt_WindowFrameSection_keys[] = { + "NoSection" + , "LeftSection" + , "TopLeftSection" + , "TopSection" + , "TopRightSection" + , "RightSection" + , "BottomRightSection" + , "BottomSection" + , "BottomLeftSection" + , "TitleBarArea" +}; + +static QString qtscript_Qt_WindowFrameSection_toStringHelper(Qt::WindowFrameSection value) +{ + if ((value >= Qt::NoSection) && (value <= Qt::TitleBarArea)) + return qtscript_Qt_WindowFrameSection_keys[static_cast<int>(value)-static_cast<int>(Qt::NoSection)]; + return QString(); +} + +static QScriptValue qtscript_Qt_WindowFrameSection_toScriptValue(QScriptEngine *engine, const Qt::WindowFrameSection &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WindowFrameSection_toStringHelper(value)); +} + +static void qtscript_Qt_WindowFrameSection_fromScriptValue(const QScriptValue &value, Qt::WindowFrameSection &out) +{ + out = qvariant_cast<Qt::WindowFrameSection>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WindowFrameSection(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::NoSection) && (arg <= Qt::TitleBarArea)) + return qScriptValueFromValue(engine, static_cast<Qt::WindowFrameSection>(arg)); + return context->throwError(QString::fromLatin1("WindowFrameSection(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WindowFrameSection_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowFrameSection value = qscriptvalue_cast<Qt::WindowFrameSection>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowFrameSection_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowFrameSection value = qscriptvalue_cast<Qt::WindowFrameSection>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WindowFrameSection_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WindowFrameSection_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WindowFrameSection, + qtscript_Qt_WindowFrameSection_valueOf, qtscript_Qt_WindowFrameSection_toString); + qScriptRegisterMetaType<Qt::WindowFrameSection>(engine, qtscript_Qt_WindowFrameSection_toScriptValue, + qtscript_Qt_WindowFrameSection_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 10; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WindowFrameSection_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WindowFrameSection_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::InputMethodQuery +// + +static const Qt::InputMethodQuery qtscript_Qt_InputMethodQuery_values[] = { + Qt::ImMicroFocus + , Qt::ImFont + , Qt::ImCursorPosition + , Qt::ImSurroundingText + , Qt::ImCurrentSelection +}; + +static const char * const qtscript_Qt_InputMethodQuery_keys[] = { + "ImMicroFocus" + , "ImFont" + , "ImCursorPosition" + , "ImSurroundingText" + , "ImCurrentSelection" +}; + +static QString qtscript_Qt_InputMethodQuery_toStringHelper(Qt::InputMethodQuery value) +{ + if ((value >= Qt::ImMicroFocus) && (value <= Qt::ImCurrentSelection)) + return qtscript_Qt_InputMethodQuery_keys[static_cast<int>(value)-static_cast<int>(Qt::ImMicroFocus)]; + return QString(); +} + +static QScriptValue qtscript_Qt_InputMethodQuery_toScriptValue(QScriptEngine *engine, const Qt::InputMethodQuery &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_InputMethodQuery_toStringHelper(value)); +} + +static void qtscript_Qt_InputMethodQuery_fromScriptValue(const QScriptValue &value, Qt::InputMethodQuery &out) +{ + out = qvariant_cast<Qt::InputMethodQuery>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_InputMethodQuery(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::ImMicroFocus) && (arg <= Qt::ImCurrentSelection)) + return qScriptValueFromValue(engine, static_cast<Qt::InputMethodQuery>(arg)); + return context->throwError(QString::fromLatin1("InputMethodQuery(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_InputMethodQuery_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::InputMethodQuery value = qscriptvalue_cast<Qt::InputMethodQuery>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_InputMethodQuery_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::InputMethodQuery value = qscriptvalue_cast<Qt::InputMethodQuery>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_InputMethodQuery_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_InputMethodQuery_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_InputMethodQuery, + qtscript_Qt_InputMethodQuery_valueOf, qtscript_Qt_InputMethodQuery_toString); + qScriptRegisterMetaType<Qt::InputMethodQuery>(engine, qtscript_Qt_InputMethodQuery_toScriptValue, + qtscript_Qt_InputMethodQuery_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_InputMethodQuery_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_InputMethodQuery_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DropAction +// + +static const Qt::DropAction qtscript_Qt_DropAction_values[] = { + Qt::IgnoreAction + , Qt::CopyAction + , Qt::MoveAction + , Qt::LinkAction + , Qt::ActionMask + , Qt::TargetMoveAction +}; + +static const char * const qtscript_Qt_DropAction_keys[] = { + "IgnoreAction" + , "CopyAction" + , "MoveAction" + , "LinkAction" + , "ActionMask" + , "TargetMoveAction" +}; + +static QString qtscript_Qt_DropAction_toStringHelper(Qt::DropAction value) +{ + for (int i = 0; i < 6; ++i) { + if (qtscript_Qt_DropAction_values[i] == value) + return QString::fromLatin1(qtscript_Qt_DropAction_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_DropAction_toScriptValue(QScriptEngine *engine, const Qt::DropAction &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_DropAction_toStringHelper(value)); +} + +static void qtscript_Qt_DropAction_fromScriptValue(const QScriptValue &value, Qt::DropAction &out) +{ + out = qvariant_cast<Qt::DropAction>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_DropAction(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 6; ++i) { + if (qtscript_Qt_DropAction_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::DropAction>(arg)); + } + return context->throwError(QString::fromLatin1("DropAction(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_DropAction_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DropAction value = qscriptvalue_cast<Qt::DropAction>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DropAction_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DropAction value = qscriptvalue_cast<Qt::DropAction>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_DropAction_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_DropAction_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_DropAction, + qtscript_Qt_DropAction_valueOf, qtscript_Qt_DropAction_toString); + qScriptRegisterMetaType<Qt::DropAction>(engine, qtscript_Qt_DropAction_toScriptValue, + qtscript_Qt_DropAction_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 6; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_DropAction_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_DropAction_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DropActions +// + +static QScriptValue qtscript_Qt_DropActions_toScriptValue(QScriptEngine *engine, const Qt::DropActions &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_DropActions_fromScriptValue(const QScriptValue &value, Qt::DropActions &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::DropActions>()) + out = qvariant_cast<Qt::DropActions>(var); + else if (var.userType() == qMetaTypeId<Qt::DropAction>()) + out = qvariant_cast<Qt::DropAction>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_DropActions(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DropActions result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::DropActions>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::DropAction>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("DropActions(): argument %0 is not of type DropAction").arg(i)); + } + result |= qvariant_cast<Qt::DropAction>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_DropActions_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DropActions value = qscriptvalue_cast<Qt::DropActions>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DropActions_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DropActions value = qscriptvalue_cast<Qt::DropActions>(context->thisObject()); + QString result; + for (int i = 0; i < 6; ++i) { + if ((value & qtscript_Qt_DropAction_values[i]) == qtscript_Qt_DropAction_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_DropAction_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_DropActions_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::DropActions>() == otherObj.value<Qt::DropActions>()))); +} + +static QScriptValue qtscript_create_Qt_DropActions_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_DropActions, qtscript_Qt_DropActions_valueOf, + qtscript_Qt_DropActions_toString, qtscript_Qt_DropActions_equals); + qScriptRegisterMetaType<Qt::DropActions>(engine, qtscript_Qt_DropActions_toScriptValue, + qtscript_Qt_DropActions_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::FillRule +// + +static const Qt::FillRule qtscript_Qt_FillRule_values[] = { + Qt::OddEvenFill + , Qt::WindingFill +}; + +static const char * const qtscript_Qt_FillRule_keys[] = { + "OddEvenFill" + , "WindingFill" +}; + +static QString qtscript_Qt_FillRule_toStringHelper(Qt::FillRule value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("FillRule"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_FillRule_toScriptValue(QScriptEngine *engine, const Qt::FillRule &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_FillRule_toStringHelper(value)); +} + +static void qtscript_Qt_FillRule_fromScriptValue(const QScriptValue &value, Qt::FillRule &out) +{ + out = qvariant_cast<Qt::FillRule>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_FillRule(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("FillRule"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::FillRule>(arg)); + return context->throwError(QString::fromLatin1("FillRule(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_FillRule_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FillRule value = qscriptvalue_cast<Qt::FillRule>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_FillRule_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::FillRule value = qscriptvalue_cast<Qt::FillRule>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_FillRule_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_FillRule_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_FillRule, + qtscript_Qt_FillRule_valueOf, qtscript_Qt_FillRule_toString); + qScriptRegisterMetaType<Qt::FillRule>(engine, qtscript_Qt_FillRule_toScriptValue, + qtscript_Qt_FillRule_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_FillRule_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_FillRule_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::GlobalColor +// + +static const Qt::GlobalColor qtscript_Qt_GlobalColor_values[] = { + Qt::color0 + , Qt::color1 + , Qt::black + , Qt::white + , Qt::darkGray + , Qt::gray + , Qt::lightGray + , Qt::red + , Qt::green + , Qt::blue + , Qt::cyan + , Qt::magenta + , Qt::yellow + , Qt::darkRed + , Qt::darkGreen + , Qt::darkBlue + , Qt::darkCyan + , Qt::darkMagenta + , Qt::darkYellow + , Qt::transparent +}; + +static const char * const qtscript_Qt_GlobalColor_keys[] = { + "color0" + , "color1" + , "black" + , "white" + , "darkGray" + , "gray" + , "lightGray" + , "red" + , "green" + , "blue" + , "cyan" + , "magenta" + , "yellow" + , "darkRed" + , "darkGreen" + , "darkBlue" + , "darkCyan" + , "darkMagenta" + , "darkYellow" + , "transparent" +}; + +static QString qtscript_Qt_GlobalColor_toStringHelper(Qt::GlobalColor value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("GlobalColor"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_GlobalColor_toScriptValue(QScriptEngine *engine, const Qt::GlobalColor &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_GlobalColor_toStringHelper(value)); +} + +static void qtscript_Qt_GlobalColor_fromScriptValue(const QScriptValue &value, Qt::GlobalColor &out) +{ + out = qvariant_cast<Qt::GlobalColor>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_GlobalColor(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("GlobalColor"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::GlobalColor>(arg)); + return context->throwError(QString::fromLatin1("GlobalColor(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_GlobalColor_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::GlobalColor value = qscriptvalue_cast<Qt::GlobalColor>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_GlobalColor_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::GlobalColor value = qscriptvalue_cast<Qt::GlobalColor>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_GlobalColor_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_GlobalColor_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_GlobalColor, + qtscript_Qt_GlobalColor_valueOf, qtscript_Qt_GlobalColor_toString); + qScriptRegisterMetaType<Qt::GlobalColor>(engine, qtscript_Qt_GlobalColor_toScriptValue, + qtscript_Qt_GlobalColor_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 20; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_GlobalColor_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_GlobalColor_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ConnectionType +// + +static const Qt::ConnectionType qtscript_Qt_ConnectionType_values[] = { + Qt::AutoConnection + , Qt::DirectConnection + , Qt::QueuedConnection + , Qt::AutoCompatConnection + , Qt::BlockingQueuedConnection +}; + +static const char * const qtscript_Qt_ConnectionType_keys[] = { + "AutoConnection" + , "DirectConnection" + , "QueuedConnection" + , "AutoCompatConnection" + , "BlockingQueuedConnection" +}; + +static QString qtscript_Qt_ConnectionType_toStringHelper(Qt::ConnectionType value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ConnectionType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ConnectionType_toScriptValue(QScriptEngine *engine, const Qt::ConnectionType &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ConnectionType_toStringHelper(value)); +} + +static void qtscript_Qt_ConnectionType_fromScriptValue(const QScriptValue &value, Qt::ConnectionType &out) +{ + out = qvariant_cast<Qt::ConnectionType>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ConnectionType(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ConnectionType"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ConnectionType>(arg)); + return context->throwError(QString::fromLatin1("ConnectionType(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ConnectionType_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ConnectionType value = qscriptvalue_cast<Qt::ConnectionType>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ConnectionType_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ConnectionType value = qscriptvalue_cast<Qt::ConnectionType>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ConnectionType_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ConnectionType_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ConnectionType, + qtscript_Qt_ConnectionType_valueOf, qtscript_Qt_ConnectionType_toString); + qScriptRegisterMetaType<Qt::ConnectionType>(engine, qtscript_Qt_ConnectionType_toScriptValue, + qtscript_Qt_ConnectionType_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ConnectionType_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ConnectionType_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::PenCapStyle +// + +static const Qt::PenCapStyle qtscript_Qt_PenCapStyle_values[] = { + Qt::FlatCap + , Qt::SquareCap + , Qt::RoundCap + , Qt::MPenCapStyle +}; + +static const char * const qtscript_Qt_PenCapStyle_keys[] = { + "FlatCap" + , "SquareCap" + , "RoundCap" + , "MPenCapStyle" +}; + +static QString qtscript_Qt_PenCapStyle_toStringHelper(Qt::PenCapStyle value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenCapStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_PenCapStyle_toScriptValue(QScriptEngine *engine, const Qt::PenCapStyle &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_PenCapStyle_toStringHelper(value)); +} + +static void qtscript_Qt_PenCapStyle_fromScriptValue(const QScriptValue &value, Qt::PenCapStyle &out) +{ + out = qvariant_cast<Qt::PenCapStyle>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_PenCapStyle(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenCapStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::PenCapStyle>(arg)); + return context->throwError(QString::fromLatin1("PenCapStyle(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_PenCapStyle_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenCapStyle value = qscriptvalue_cast<Qt::PenCapStyle>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_PenCapStyle_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenCapStyle value = qscriptvalue_cast<Qt::PenCapStyle>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_PenCapStyle_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_PenCapStyle_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_PenCapStyle, + qtscript_Qt_PenCapStyle_valueOf, qtscript_Qt_PenCapStyle_toString); + qScriptRegisterMetaType<Qt::PenCapStyle>(engine, qtscript_Qt_PenCapStyle_toScriptValue, + qtscript_Qt_PenCapStyle_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_PenCapStyle_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_PenCapStyle_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TransformationMode +// + +static const Qt::TransformationMode qtscript_Qt_TransformationMode_values[] = { + Qt::FastTransformation + , Qt::SmoothTransformation +}; + +static const char * const qtscript_Qt_TransformationMode_keys[] = { + "FastTransformation" + , "SmoothTransformation" +}; + +static QString qtscript_Qt_TransformationMode_toStringHelper(Qt::TransformationMode value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TransformationMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_TransformationMode_toScriptValue(QScriptEngine *engine, const Qt::TransformationMode &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TransformationMode_toStringHelper(value)); +} + +static void qtscript_Qt_TransformationMode_fromScriptValue(const QScriptValue &value, Qt::TransformationMode &out) +{ + out = qvariant_cast<Qt::TransformationMode>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TransformationMode(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TransformationMode"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::TransformationMode>(arg)); + return context->throwError(QString::fromLatin1("TransformationMode(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TransformationMode_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TransformationMode value = qscriptvalue_cast<Qt::TransformationMode>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TransformationMode_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TransformationMode value = qscriptvalue_cast<Qt::TransformationMode>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TransformationMode_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TransformationMode_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TransformationMode, + qtscript_Qt_TransformationMode_valueOf, qtscript_Qt_TransformationMode_toString); + qScriptRegisterMetaType<Qt::TransformationMode>(engine, qtscript_Qt_TransformationMode_toScriptValue, + qtscript_Qt_TransformationMode_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TransformationMode_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TransformationMode_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DockWidgetAreaSizes +// + +static const Qt::DockWidgetAreaSizes qtscript_Qt_DockWidgetAreaSizes_values[] = { + Qt::NDockWidgetAreas +}; + +static const char * const qtscript_Qt_DockWidgetAreaSizes_keys[] = { + "NDockWidgetAreas" +}; + +static QString qtscript_Qt_DockWidgetAreaSizes_toStringHelper(Qt::DockWidgetAreaSizes value) +{ + if ((value >= Qt::NDockWidgetAreas) && (value <= Qt::NDockWidgetAreas)) + return qtscript_Qt_DockWidgetAreaSizes_keys[static_cast<int>(value)-static_cast<int>(Qt::NDockWidgetAreas)]; + return QString(); +} + +static QScriptValue qtscript_Qt_DockWidgetAreaSizes_toScriptValue(QScriptEngine *engine, const Qt::DockWidgetAreaSizes &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_DockWidgetAreaSizes_toStringHelper(value)); +} + +static void qtscript_Qt_DockWidgetAreaSizes_fromScriptValue(const QScriptValue &value, Qt::DockWidgetAreaSizes &out) +{ + out = qvariant_cast<Qt::DockWidgetAreaSizes>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_DockWidgetAreaSizes(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::NDockWidgetAreas) && (arg <= Qt::NDockWidgetAreas)) + return qScriptValueFromValue(engine, static_cast<Qt::DockWidgetAreaSizes>(arg)); + return context->throwError(QString::fromLatin1("DockWidgetAreaSizes(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_DockWidgetAreaSizes_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetAreaSizes value = qscriptvalue_cast<Qt::DockWidgetAreaSizes>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DockWidgetAreaSizes_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetAreaSizes value = qscriptvalue_cast<Qt::DockWidgetAreaSizes>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_DockWidgetAreaSizes_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_DockWidgetAreaSizes_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_DockWidgetAreaSizes, + qtscript_Qt_DockWidgetAreaSizes_valueOf, qtscript_Qt_DockWidgetAreaSizes_toString); + qScriptRegisterMetaType<Qt::DockWidgetAreaSizes>(engine, qtscript_Qt_DockWidgetAreaSizes_toScriptValue, + qtscript_Qt_DockWidgetAreaSizes_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 1; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_DockWidgetAreaSizes_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_DockWidgetAreaSizes_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ApplicationAttribute +// + +static const Qt::ApplicationAttribute qtscript_Qt_ApplicationAttribute_values[] = { + Qt::AA_ImmediateWidgetCreation + , Qt::AA_MSWindowsUseDirect3DByDefault + , Qt::AA_DontShowIconsInMenus + , Qt::AA_NativeWindows + , Qt::AA_DontCreateNativeWidgetSiblings + , Qt::AA_MacPluginApplication + , Qt::AA_AttributeCount +}; + +static const char * const qtscript_Qt_ApplicationAttribute_keys[] = { + "AA_ImmediateWidgetCreation" + , "AA_MSWindowsUseDirect3DByDefault" + , "AA_DontShowIconsInMenus" + , "AA_NativeWindows" + , "AA_DontCreateNativeWidgetSiblings" + , "AA_MacPluginApplication" + , "AA_AttributeCount" +}; + +static QString qtscript_Qt_ApplicationAttribute_toStringHelper(Qt::ApplicationAttribute value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ApplicationAttribute"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ApplicationAttribute_toScriptValue(QScriptEngine *engine, const Qt::ApplicationAttribute &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ApplicationAttribute_toStringHelper(value)); +} + +static void qtscript_Qt_ApplicationAttribute_fromScriptValue(const QScriptValue &value, Qt::ApplicationAttribute &out) +{ + out = qvariant_cast<Qt::ApplicationAttribute>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ApplicationAttribute(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ApplicationAttribute"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ApplicationAttribute>(arg)); + return context->throwError(QString::fromLatin1("ApplicationAttribute(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ApplicationAttribute_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ApplicationAttribute value = qscriptvalue_cast<Qt::ApplicationAttribute>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ApplicationAttribute_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ApplicationAttribute value = qscriptvalue_cast<Qt::ApplicationAttribute>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ApplicationAttribute_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ApplicationAttribute_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ApplicationAttribute, + qtscript_Qt_ApplicationAttribute_valueOf, qtscript_Qt_ApplicationAttribute_toString); + qScriptRegisterMetaType<Qt::ApplicationAttribute>(engine, qtscript_Qt_ApplicationAttribute_toScriptValue, + qtscript_Qt_ApplicationAttribute_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 7; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ApplicationAttribute_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ApplicationAttribute_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ShortcutContext +// + +static const Qt::ShortcutContext qtscript_Qt_ShortcutContext_values[] = { + Qt::WidgetShortcut + , Qt::WindowShortcut + , Qt::ApplicationShortcut + , Qt::WidgetWithChildrenShortcut +}; + +static const char * const qtscript_Qt_ShortcutContext_keys[] = { + "WidgetShortcut" + , "WindowShortcut" + , "ApplicationShortcut" + , "WidgetWithChildrenShortcut" +}; + +static QString qtscript_Qt_ShortcutContext_toStringHelper(Qt::ShortcutContext value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ShortcutContext"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_ShortcutContext_toScriptValue(QScriptEngine *engine, const Qt::ShortcutContext &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ShortcutContext_toStringHelper(value)); +} + +static void qtscript_Qt_ShortcutContext_fromScriptValue(const QScriptValue &value, Qt::ShortcutContext &out) +{ + out = qvariant_cast<Qt::ShortcutContext>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ShortcutContext(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("ShortcutContext"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::ShortcutContext>(arg)); + return context->throwError(QString::fromLatin1("ShortcutContext(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ShortcutContext_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ShortcutContext value = qscriptvalue_cast<Qt::ShortcutContext>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ShortcutContext_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ShortcutContext value = qscriptvalue_cast<Qt::ShortcutContext>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ShortcutContext_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ShortcutContext_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ShortcutContext, + qtscript_Qt_ShortcutContext_valueOf, qtscript_Qt_ShortcutContext_toString); + qScriptRegisterMetaType<Qt::ShortcutContext>(engine, qtscript_Qt_ShortcutContext_toScriptValue, + qtscript_Qt_ShortcutContext_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ShortcutContext_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ShortcutContext_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TextInteractionFlag +// + +static const Qt::TextInteractionFlag qtscript_Qt_TextInteractionFlag_values[] = { + Qt::NoTextInteraction + , Qt::TextSelectableByMouse + , Qt::TextSelectableByKeyboard + , Qt::LinksAccessibleByMouse + , Qt::LinksAccessibleByKeyboard + , Qt::TextBrowserInteraction + , Qt::TextEditable + , Qt::TextEditorInteraction +}; + +static const char * const qtscript_Qt_TextInteractionFlag_keys[] = { + "NoTextInteraction" + , "TextSelectableByMouse" + , "TextSelectableByKeyboard" + , "LinksAccessibleByMouse" + , "LinksAccessibleByKeyboard" + , "TextBrowserInteraction" + , "TextEditable" + , "TextEditorInteraction" +}; + +static QString qtscript_Qt_TextInteractionFlag_toStringHelper(Qt::TextInteractionFlag value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextInteractionFlag"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_TextInteractionFlag_toScriptValue(QScriptEngine *engine, const Qt::TextInteractionFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TextInteractionFlag_toStringHelper(value)); +} + +static void qtscript_Qt_TextInteractionFlag_fromScriptValue(const QScriptValue &value, Qt::TextInteractionFlag &out) +{ + out = qvariant_cast<Qt::TextInteractionFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TextInteractionFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextInteractionFlag"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::TextInteractionFlag>(arg)); + return context->throwError(QString::fromLatin1("TextInteractionFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TextInteractionFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextInteractionFlag value = qscriptvalue_cast<Qt::TextInteractionFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TextInteractionFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextInteractionFlag value = qscriptvalue_cast<Qt::TextInteractionFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TextInteractionFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TextInteractionFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TextInteractionFlag, + qtscript_Qt_TextInteractionFlag_valueOf, qtscript_Qt_TextInteractionFlag_toString); + qScriptRegisterMetaType<Qt::TextInteractionFlag>(engine, qtscript_Qt_TextInteractionFlag_toScriptValue, + qtscript_Qt_TextInteractionFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 8; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TextInteractionFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TextInteractionFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TextInteractionFlags +// + +static QScriptValue qtscript_Qt_TextInteractionFlags_toScriptValue(QScriptEngine *engine, const Qt::TextInteractionFlags &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_TextInteractionFlags_fromScriptValue(const QScriptValue &value, Qt::TextInteractionFlags &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::TextInteractionFlags>()) + out = qvariant_cast<Qt::TextInteractionFlags>(var); + else if (var.userType() == qMetaTypeId<Qt::TextInteractionFlag>()) + out = qvariant_cast<Qt::TextInteractionFlag>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_TextInteractionFlags(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextInteractionFlags result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::TextInteractionFlags>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::TextInteractionFlag>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("TextInteractionFlags(): argument %0 is not of type TextInteractionFlag").arg(i)); + } + result |= qvariant_cast<Qt::TextInteractionFlag>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_TextInteractionFlags_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextInteractionFlags value = qscriptvalue_cast<Qt::TextInteractionFlags>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TextInteractionFlags_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextInteractionFlags value = qscriptvalue_cast<Qt::TextInteractionFlags>(context->thisObject()); + QString result; + for (int i = 0; i < 8; ++i) { + if ((value & qtscript_Qt_TextInteractionFlag_values[i]) == qtscript_Qt_TextInteractionFlag_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_TextInteractionFlag_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_TextInteractionFlags_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::TextInteractionFlags>() == otherObj.value<Qt::TextInteractionFlags>()))); +} + +static QScriptValue qtscript_create_Qt_TextInteractionFlags_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_TextInteractionFlags, qtscript_Qt_TextInteractionFlags_valueOf, + qtscript_Qt_TextInteractionFlags_toString, qtscript_Qt_TextInteractionFlags_equals); + qScriptRegisterMetaType<Qt::TextInteractionFlags>(engine, qtscript_Qt_TextInteractionFlags_toScriptValue, + qtscript_Qt_TextInteractionFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::CheckState +// + +static const Qt::CheckState qtscript_Qt_CheckState_values[] = { + Qt::Unchecked + , Qt::PartiallyChecked + , Qt::Checked +}; + +static const char * const qtscript_Qt_CheckState_keys[] = { + "Unchecked" + , "PartiallyChecked" + , "Checked" +}; + +static QString qtscript_Qt_CheckState_toStringHelper(Qt::CheckState value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CheckState"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_CheckState_toScriptValue(QScriptEngine *engine, const Qt::CheckState &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_CheckState_toStringHelper(value)); +} + +static void qtscript_Qt_CheckState_fromScriptValue(const QScriptValue &value, Qt::CheckState &out) +{ + out = qvariant_cast<Qt::CheckState>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_CheckState(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("CheckState"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::CheckState>(arg)); + return context->throwError(QString::fromLatin1("CheckState(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_CheckState_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CheckState value = qscriptvalue_cast<Qt::CheckState>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_CheckState_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::CheckState value = qscriptvalue_cast<Qt::CheckState>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_CheckState_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_CheckState_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_CheckState, + qtscript_Qt_CheckState_valueOf, qtscript_Qt_CheckState_toString); + qScriptRegisterMetaType<Qt::CheckState>(engine, qtscript_Qt_CheckState_toScriptValue, + qtscript_Qt_CheckState_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_CheckState_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_CheckState_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DockWidgetArea +// + +static const Qt::DockWidgetArea qtscript_Qt_DockWidgetArea_values[] = { + Qt::NoDockWidgetArea + , Qt::LeftDockWidgetArea + , Qt::RightDockWidgetArea + , Qt::TopDockWidgetArea + , Qt::BottomDockWidgetArea + , Qt::DockWidgetArea_Mask +}; + +static const char * const qtscript_Qt_DockWidgetArea_keys[] = { + "NoDockWidgetArea" + , "LeftDockWidgetArea" + , "RightDockWidgetArea" + , "TopDockWidgetArea" + , "BottomDockWidgetArea" + , "DockWidgetArea_Mask" +}; + +static QString qtscript_Qt_DockWidgetArea_toStringHelper(Qt::DockWidgetArea value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DockWidgetArea"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_DockWidgetArea_toScriptValue(QScriptEngine *engine, const Qt::DockWidgetArea &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_DockWidgetArea_toStringHelper(value)); +} + +static void qtscript_Qt_DockWidgetArea_fromScriptValue(const QScriptValue &value, Qt::DockWidgetArea &out) +{ + out = qvariant_cast<Qt::DockWidgetArea>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_DockWidgetArea(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("DockWidgetArea"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::DockWidgetArea>(arg)); + return context->throwError(QString::fromLatin1("DockWidgetArea(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_DockWidgetArea_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetArea value = qscriptvalue_cast<Qt::DockWidgetArea>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DockWidgetArea_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetArea value = qscriptvalue_cast<Qt::DockWidgetArea>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_DockWidgetArea_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_DockWidgetArea_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_DockWidgetArea, + qtscript_Qt_DockWidgetArea_valueOf, qtscript_Qt_DockWidgetArea_toString); + qScriptRegisterMetaType<Qt::DockWidgetArea>(engine, qtscript_Qt_DockWidgetArea_toScriptValue, + qtscript_Qt_DockWidgetArea_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 6; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_DockWidgetArea_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_DockWidgetArea_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::DockWidgetAreas +// + +static QScriptValue qtscript_Qt_DockWidgetAreas_toScriptValue(QScriptEngine *engine, const Qt::DockWidgetAreas &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_DockWidgetAreas_fromScriptValue(const QScriptValue &value, Qt::DockWidgetAreas &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::DockWidgetAreas>()) + out = qvariant_cast<Qt::DockWidgetAreas>(var); + else if (var.userType() == qMetaTypeId<Qt::DockWidgetArea>()) + out = qvariant_cast<Qt::DockWidgetArea>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_DockWidgetAreas(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetAreas result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::DockWidgetAreas>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::DockWidgetArea>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("DockWidgetAreas(): argument %0 is not of type DockWidgetArea").arg(i)); + } + result |= qvariant_cast<Qt::DockWidgetArea>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_DockWidgetAreas_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetAreas value = qscriptvalue_cast<Qt::DockWidgetAreas>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_DockWidgetAreas_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::DockWidgetAreas value = qscriptvalue_cast<Qt::DockWidgetAreas>(context->thisObject()); + QString result; + for (int i = 0; i < 6; ++i) { + if ((value & qtscript_Qt_DockWidgetArea_values[i]) == qtscript_Qt_DockWidgetArea_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_DockWidgetArea_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_DockWidgetAreas_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::DockWidgetAreas>() == otherObj.value<Qt::DockWidgetAreas>()))); +} + +static QScriptValue qtscript_create_Qt_DockWidgetAreas_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_DockWidgetAreas, qtscript_Qt_DockWidgetAreas_valueOf, + qtscript_Qt_DockWidgetAreas_toString, qtscript_Qt_DockWidgetAreas_equals); + qScriptRegisterMetaType<Qt::DockWidgetAreas>(engine, qtscript_Qt_DockWidgetAreas_toScriptValue, + qtscript_Qt_DockWidgetAreas_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::TimeSpec +// + +static const Qt::TimeSpec qtscript_Qt_TimeSpec_values[] = { + Qt::LocalTime + , Qt::UTC + , Qt::OffsetFromUTC +}; + +static const char * const qtscript_Qt_TimeSpec_keys[] = { + "LocalTime" + , "UTC" + , "OffsetFromUTC" +}; + +static QString qtscript_Qt_TimeSpec_toStringHelper(Qt::TimeSpec value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TimeSpec"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_TimeSpec_toScriptValue(QScriptEngine *engine, const Qt::TimeSpec &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TimeSpec_toStringHelper(value)); +} + +static void qtscript_Qt_TimeSpec_fromScriptValue(const QScriptValue &value, Qt::TimeSpec &out) +{ + out = qvariant_cast<Qt::TimeSpec>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TimeSpec(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TimeSpec"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::TimeSpec>(arg)); + return context->throwError(QString::fromLatin1("TimeSpec(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TimeSpec_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TimeSpec value = qscriptvalue_cast<Qt::TimeSpec>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TimeSpec_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TimeSpec value = qscriptvalue_cast<Qt::TimeSpec>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TimeSpec_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TimeSpec_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TimeSpec, + qtscript_Qt_TimeSpec_valueOf, qtscript_Qt_TimeSpec_toString); + qScriptRegisterMetaType<Qt::TimeSpec>(engine, qtscript_Qt_TimeSpec_toScriptValue, + qtscript_Qt_TimeSpec_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TimeSpec_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TimeSpec_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ImageConversionFlag +// + +static const Qt::ImageConversionFlag qtscript_Qt_ImageConversionFlag_values[] = { + Qt::AutoColor + , Qt::MonoOnly + , Qt::ColorMode_Mask + , Qt::OrderedAlphaDither + , Qt::DiffuseAlphaDither + , Qt::AlphaDither_Mask + , Qt::OrderedDither + , Qt::ThresholdDither + , Qt::Dither_Mask + , Qt::PreferDither + , Qt::AvoidDither + , Qt::DitherMode_Mask + , Qt::NoOpaqueDetection +}; + +static const char * const qtscript_Qt_ImageConversionFlag_keys[] = { + "AutoColor" + , "MonoOnly" + , "ColorMode_Mask" + , "OrderedAlphaDither" + , "DiffuseAlphaDither" + , "AlphaDither_Mask" + , "OrderedDither" + , "ThresholdDither" + , "Dither_Mask" + , "PreferDither" + , "AvoidDither" + , "DitherMode_Mask" + , "NoOpaqueDetection" +}; + +static QString qtscript_Qt_ImageConversionFlag_toStringHelper(Qt::ImageConversionFlag value) +{ + for (int i = 0; i < 13; ++i) { + if (qtscript_Qt_ImageConversionFlag_values[i] == value) + return QString::fromLatin1(qtscript_Qt_ImageConversionFlag_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_ImageConversionFlag_toScriptValue(QScriptEngine *engine, const Qt::ImageConversionFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ImageConversionFlag_toStringHelper(value)); +} + +static void qtscript_Qt_ImageConversionFlag_fromScriptValue(const QScriptValue &value, Qt::ImageConversionFlag &out) +{ + out = qvariant_cast<Qt::ImageConversionFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ImageConversionFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 13; ++i) { + if (qtscript_Qt_ImageConversionFlag_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::ImageConversionFlag>(arg)); + } + return context->throwError(QString::fromLatin1("ImageConversionFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ImageConversionFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ImageConversionFlag value = qscriptvalue_cast<Qt::ImageConversionFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ImageConversionFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ImageConversionFlag value = qscriptvalue_cast<Qt::ImageConversionFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ImageConversionFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ImageConversionFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ImageConversionFlag, + qtscript_Qt_ImageConversionFlag_valueOf, qtscript_Qt_ImageConversionFlag_toString); + qScriptRegisterMetaType<Qt::ImageConversionFlag>(engine, qtscript_Qt_ImageConversionFlag_toScriptValue, + qtscript_Qt_ImageConversionFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 13; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ImageConversionFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ImageConversionFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ImageConversionFlags +// + +static QScriptValue qtscript_Qt_ImageConversionFlags_toScriptValue(QScriptEngine *engine, const Qt::ImageConversionFlags &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_ImageConversionFlags_fromScriptValue(const QScriptValue &value, Qt::ImageConversionFlags &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::ImageConversionFlags>()) + out = qvariant_cast<Qt::ImageConversionFlags>(var); + else if (var.userType() == qMetaTypeId<Qt::ImageConversionFlag>()) + out = qvariant_cast<Qt::ImageConversionFlag>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_ImageConversionFlags(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ImageConversionFlags result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::ImageConversionFlags>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::ImageConversionFlag>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("ImageConversionFlags(): argument %0 is not of type ImageConversionFlag").arg(i)); + } + result |= qvariant_cast<Qt::ImageConversionFlag>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_ImageConversionFlags_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ImageConversionFlags value = qscriptvalue_cast<Qt::ImageConversionFlags>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ImageConversionFlags_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ImageConversionFlags value = qscriptvalue_cast<Qt::ImageConversionFlags>(context->thisObject()); + QString result; + for (int i = 0; i < 13; ++i) { + if ((value & qtscript_Qt_ImageConversionFlag_values[i]) == qtscript_Qt_ImageConversionFlag_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_ImageConversionFlag_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_ImageConversionFlags_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::ImageConversionFlags>() == otherObj.value<Qt::ImageConversionFlags>()))); +} + +static QScriptValue qtscript_create_Qt_ImageConversionFlags_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_ImageConversionFlags, qtscript_Qt_ImageConversionFlags_valueOf, + qtscript_Qt_ImageConversionFlags_toString, qtscript_Qt_ImageConversionFlags_equals); + qScriptRegisterMetaType<Qt::ImageConversionFlags>(engine, qtscript_Qt_ImageConversionFlags_toScriptValue, + qtscript_Qt_ImageConversionFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::WindowModality +// + +static const Qt::WindowModality qtscript_Qt_WindowModality_values[] = { + Qt::NonModal + , Qt::WindowModal + , Qt::ApplicationModal +}; + +static const char * const qtscript_Qt_WindowModality_keys[] = { + "NonModal" + , "WindowModal" + , "ApplicationModal" +}; + +static QString qtscript_Qt_WindowModality_toStringHelper(Qt::WindowModality value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowModality"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_WindowModality_toScriptValue(QScriptEngine *engine, const Qt::WindowModality &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WindowModality_toStringHelper(value)); +} + +static void qtscript_Qt_WindowModality_fromScriptValue(const QScriptValue &value, Qt::WindowModality &out) +{ + out = qvariant_cast<Qt::WindowModality>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WindowModality(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowModality"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::WindowModality>(arg)); + return context->throwError(QString::fromLatin1("WindowModality(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WindowModality_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowModality value = qscriptvalue_cast<Qt::WindowModality>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowModality_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowModality value = qscriptvalue_cast<Qt::WindowModality>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WindowModality_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WindowModality_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WindowModality, + qtscript_Qt_WindowModality_valueOf, qtscript_Qt_WindowModality_toString); + qScriptRegisterMetaType<Qt::WindowModality>(engine, qtscript_Qt_WindowModality_toScriptValue, + qtscript_Qt_WindowModality_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 3; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WindowModality_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WindowModality_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Modifier +// + +static const Qt::Modifier qtscript_Qt_Modifier_values[] = { + Qt::MODIFIER_MASK + , Qt::UNICODE_ACCEL + , Qt::SHIFT + , Qt::CTRL + , Qt::ALT + , Qt::META +}; + +static const char * const qtscript_Qt_Modifier_keys[] = { + "MODIFIER_MASK" + , "UNICODE_ACCEL" + , "SHIFT" + , "CTRL" + , "ALT" + , "META" +}; + +static QString qtscript_Qt_Modifier_toStringHelper(Qt::Modifier value) +{ + for (int i = 0; i < 6; ++i) { + if (qtscript_Qt_Modifier_values[i] == value) + return QString::fromLatin1(qtscript_Qt_Modifier_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_Modifier_toScriptValue(QScriptEngine *engine, const Qt::Modifier &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_Modifier_toStringHelper(value)); +} + +static void qtscript_Qt_Modifier_fromScriptValue(const QScriptValue &value, Qt::Modifier &out) +{ + out = qvariant_cast<Qt::Modifier>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_Modifier(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 6; ++i) { + if (qtscript_Qt_Modifier_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::Modifier>(arg)); + } + return context->throwError(QString::fromLatin1("Modifier(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_Modifier_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Modifier value = qscriptvalue_cast<Qt::Modifier>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Modifier_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Modifier value = qscriptvalue_cast<Qt::Modifier>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_Modifier_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_Modifier_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_Modifier, + qtscript_Qt_Modifier_valueOf, qtscript_Qt_Modifier_toString); + qScriptRegisterMetaType<Qt::Modifier>(engine, qtscript_Qt_Modifier_toScriptValue, + qtscript_Qt_Modifier_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 6; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_Modifier_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_Modifier_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::AlignmentFlag +// + +static const Qt::AlignmentFlag qtscript_Qt_AlignmentFlag_values[] = { + Qt::AlignLeft + , Qt::AlignRight + , Qt::AlignHCenter + , Qt::AlignJustify + , Qt::AlignAbsolute + , Qt::AlignHorizontal_Mask + , Qt::AlignTop + , Qt::AlignBottom + , Qt::AlignVCenter + , Qt::AlignCenter + , Qt::AlignVertical_Mask +}; + +static const char * const qtscript_Qt_AlignmentFlag_keys[] = { + "AlignLeft" + , "AlignRight" + , "AlignHCenter" + , "AlignJustify" + , "AlignAbsolute" + , "AlignHorizontal_Mask" + , "AlignTop" + , "AlignBottom" + , "AlignVCenter" + , "AlignCenter" + , "AlignVertical_Mask" +}; + +static QString qtscript_Qt_AlignmentFlag_toStringHelper(Qt::AlignmentFlag value) +{ + for (int i = 0; i < 11; ++i) { + if (qtscript_Qt_AlignmentFlag_values[i] == value) + return QString::fromLatin1(qtscript_Qt_AlignmentFlag_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_AlignmentFlag_toScriptValue(QScriptEngine *engine, const Qt::AlignmentFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_AlignmentFlag_toStringHelper(value)); +} + +static void qtscript_Qt_AlignmentFlag_fromScriptValue(const QScriptValue &value, Qt::AlignmentFlag &out) +{ + out = qvariant_cast<Qt::AlignmentFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_AlignmentFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 11; ++i) { + if (qtscript_Qt_AlignmentFlag_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::AlignmentFlag>(arg)); + } + return context->throwError(QString::fromLatin1("AlignmentFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_AlignmentFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AlignmentFlag value = qscriptvalue_cast<Qt::AlignmentFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_AlignmentFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::AlignmentFlag value = qscriptvalue_cast<Qt::AlignmentFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_AlignmentFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_AlignmentFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_AlignmentFlag, + qtscript_Qt_AlignmentFlag_valueOf, qtscript_Qt_AlignmentFlag_toString); + qScriptRegisterMetaType<Qt::AlignmentFlag>(engine, qtscript_Qt_AlignmentFlag_toScriptValue, + qtscript_Qt_AlignmentFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 11; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_AlignmentFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_AlignmentFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::Alignment +// + +static QScriptValue qtscript_Qt_Alignment_toScriptValue(QScriptEngine *engine, const Qt::Alignment &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_Alignment_fromScriptValue(const QScriptValue &value, Qt::Alignment &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::Alignment>()) + out = qvariant_cast<Qt::Alignment>(var); + else if (var.userType() == qMetaTypeId<Qt::AlignmentFlag>()) + out = qvariant_cast<Qt::AlignmentFlag>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_Alignment(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Alignment result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::Alignment>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::AlignmentFlag>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("Alignment(): argument %0 is not of type AlignmentFlag").arg(i)); + } + result |= qvariant_cast<Qt::AlignmentFlag>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_Alignment_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Alignment value = qscriptvalue_cast<Qt::Alignment>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_Alignment_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::Alignment value = qscriptvalue_cast<Qt::Alignment>(context->thisObject()); + QString result; + for (int i = 0; i < 11; ++i) { + if ((value & qtscript_Qt_AlignmentFlag_values[i]) == qtscript_Qt_AlignmentFlag_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_AlignmentFlag_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_Alignment_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::Alignment>() == otherObj.value<Qt::Alignment>()))); +} + +static QScriptValue qtscript_create_Qt_Alignment_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_Alignment, qtscript_Qt_Alignment_valueOf, + qtscript_Qt_Alignment_toString, qtscript_Qt_Alignment_equals); + qScriptRegisterMetaType<Qt::Alignment>(engine, qtscript_Qt_Alignment_toScriptValue, + qtscript_Qt_Alignment_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::WidgetAttribute +// + +static const Qt::WidgetAttribute qtscript_Qt_WidgetAttribute_values[] = { + Qt::WA_Disabled + , Qt::WA_UnderMouse + , Qt::WA_MouseTracking + , Qt::WA_ContentsPropagated + , Qt::WA_OpaquePaintEvent + , Qt::WA_StaticContents + , Qt::WA_LaidOut + , Qt::WA_PaintOnScreen + , Qt::WA_NoSystemBackground + , Qt::WA_UpdatesDisabled + , Qt::WA_Mapped + , Qt::WA_MacNoClickThrough + , Qt::WA_PaintOutsidePaintEvent + , Qt::WA_InputMethodEnabled + , Qt::WA_WState_Visible + , Qt::WA_WState_Hidden + , Qt::WA_ForceDisabled + , Qt::WA_KeyCompression + , Qt::WA_PendingMoveEvent + , Qt::WA_PendingResizeEvent + , Qt::WA_SetPalette + , Qt::WA_SetFont + , Qt::WA_SetCursor + , Qt::WA_NoChildEventsFromChildren + , Qt::WA_WindowModified + , Qt::WA_Resized + , Qt::WA_Moved + , Qt::WA_PendingUpdate + , Qt::WA_InvalidSize + , Qt::WA_MacBrushedMetal + , Qt::WA_CustomWhatsThis + , Qt::WA_LayoutOnEntireRect + , Qt::WA_OutsideWSRange + , Qt::WA_GrabbedShortcut + , Qt::WA_TransparentForMouseEvents + , Qt::WA_PaintUnclipped + , Qt::WA_SetWindowIcon + , Qt::WA_NoMouseReplay + , Qt::WA_DeleteOnClose + , Qt::WA_RightToLeft + , Qt::WA_SetLayoutDirection + , Qt::WA_NoChildEventsForParent + , Qt::WA_ForceUpdatesDisabled + , Qt::WA_WState_Created + , Qt::WA_WState_CompressKeys + , Qt::WA_WState_InPaintEvent + , Qt::WA_WState_Reparented + , Qt::WA_WState_ConfigPending + , Qt::WA_WState_Polished + , Qt::WA_WState_DND + , Qt::WA_WState_OwnSizePolicy + , Qt::WA_WState_ExplicitShowHide + , Qt::WA_ShowModal + , Qt::WA_MouseNoMask + , Qt::WA_GroupLeader + , Qt::WA_NoMousePropagation + , Qt::WA_Hover + , Qt::WA_InputMethodTransparent + , Qt::WA_QuitOnClose + , Qt::WA_KeyboardFocusChange + , Qt::WA_AcceptDrops + , Qt::WA_DropSiteRegistered + , Qt::WA_WindowPropagation + , Qt::WA_NoX11EventCompression + , Qt::WA_TintedBackground + , Qt::WA_X11OpenGLOverlay + , Qt::WA_AlwaysShowToolTips + , Qt::WA_MacOpaqueSizeGrip + , Qt::WA_SetStyle + , Qt::WA_SetLocale + , Qt::WA_MacShowFocusRect + , Qt::WA_MacNormalSize + , Qt::WA_MacSmallSize + , Qt::WA_MacMiniSize + , Qt::WA_LayoutUsesWidgetRect + , Qt::WA_StyledBackground + , Qt::WA_MSWindowsUseDirect3D + , Qt::WA_CanHostQMdiSubWindowTitleBar + , Qt::WA_MacAlwaysShowToolWindow + , Qt::WA_StyleSheet + , Qt::WA_ShowWithoutActivating + , Qt::WA_X11BypassTransientForHint + , Qt::WA_NativeWindow + , Qt::WA_DontCreateNativeAncestors + , Qt::WA_MacVariableSize + , Qt::WA_DontShowOnScreen + , Qt::WA_X11NetWmWindowTypeDesktop + , Qt::WA_X11NetWmWindowTypeDock + , Qt::WA_X11NetWmWindowTypeToolBar + , Qt::WA_X11NetWmWindowTypeMenu + , Qt::WA_X11NetWmWindowTypeUtility + , Qt::WA_X11NetWmWindowTypeSplash + , Qt::WA_X11NetWmWindowTypeDialog + , Qt::WA_X11NetWmWindowTypeDropDownMenu + , Qt::WA_X11NetWmWindowTypePopupMenu + , Qt::WA_X11NetWmWindowTypeToolTip + , Qt::WA_X11NetWmWindowTypeNotification + , Qt::WA_X11NetWmWindowTypeCombo + , Qt::WA_X11NetWmWindowTypeDND + , Qt::WA_MacFrameworkScaled + , Qt::WA_SetWindowModality + , Qt::WA_WState_WindowOpacitySet + , Qt::WA_TranslucentBackground + , Qt::WA_AttributeCount +}; + +static const char * const qtscript_Qt_WidgetAttribute_keys[] = { + "WA_Disabled" + , "WA_UnderMouse" + , "WA_MouseTracking" + , "WA_ContentsPropagated" + , "WA_OpaquePaintEvent" + , "WA_StaticContents" + , "WA_LaidOut" + , "WA_PaintOnScreen" + , "WA_NoSystemBackground" + , "WA_UpdatesDisabled" + , "WA_Mapped" + , "WA_MacNoClickThrough" + , "WA_PaintOutsidePaintEvent" + , "WA_InputMethodEnabled" + , "WA_WState_Visible" + , "WA_WState_Hidden" + , "WA_ForceDisabled" + , "WA_KeyCompression" + , "WA_PendingMoveEvent" + , "WA_PendingResizeEvent" + , "WA_SetPalette" + , "WA_SetFont" + , "WA_SetCursor" + , "WA_NoChildEventsFromChildren" + , "WA_WindowModified" + , "WA_Resized" + , "WA_Moved" + , "WA_PendingUpdate" + , "WA_InvalidSize" + , "WA_MacBrushedMetal" + , "WA_CustomWhatsThis" + , "WA_LayoutOnEntireRect" + , "WA_OutsideWSRange" + , "WA_GrabbedShortcut" + , "WA_TransparentForMouseEvents" + , "WA_PaintUnclipped" + , "WA_SetWindowIcon" + , "WA_NoMouseReplay" + , "WA_DeleteOnClose" + , "WA_RightToLeft" + , "WA_SetLayoutDirection" + , "WA_NoChildEventsForParent" + , "WA_ForceUpdatesDisabled" + , "WA_WState_Created" + , "WA_WState_CompressKeys" + , "WA_WState_InPaintEvent" + , "WA_WState_Reparented" + , "WA_WState_ConfigPending" + , "WA_WState_Polished" + , "WA_WState_DND" + , "WA_WState_OwnSizePolicy" + , "WA_WState_ExplicitShowHide" + , "WA_ShowModal" + , "WA_MouseNoMask" + , "WA_GroupLeader" + , "WA_NoMousePropagation" + , "WA_Hover" + , "WA_InputMethodTransparent" + , "WA_QuitOnClose" + , "WA_KeyboardFocusChange" + , "WA_AcceptDrops" + , "WA_DropSiteRegistered" + , "WA_WindowPropagation" + , "WA_NoX11EventCompression" + , "WA_TintedBackground" + , "WA_X11OpenGLOverlay" + , "WA_AlwaysShowToolTips" + , "WA_MacOpaqueSizeGrip" + , "WA_SetStyle" + , "WA_SetLocale" + , "WA_MacShowFocusRect" + , "WA_MacNormalSize" + , "WA_MacSmallSize" + , "WA_MacMiniSize" + , "WA_LayoutUsesWidgetRect" + , "WA_StyledBackground" + , "WA_MSWindowsUseDirect3D" + , "WA_CanHostQMdiSubWindowTitleBar" + , "WA_MacAlwaysShowToolWindow" + , "WA_StyleSheet" + , "WA_ShowWithoutActivating" + , "WA_X11BypassTransientForHint" + , "WA_NativeWindow" + , "WA_DontCreateNativeAncestors" + , "WA_MacVariableSize" + , "WA_DontShowOnScreen" + , "WA_X11NetWmWindowTypeDesktop" + , "WA_X11NetWmWindowTypeDock" + , "WA_X11NetWmWindowTypeToolBar" + , "WA_X11NetWmWindowTypeMenu" + , "WA_X11NetWmWindowTypeUtility" + , "WA_X11NetWmWindowTypeSplash" + , "WA_X11NetWmWindowTypeDialog" + , "WA_X11NetWmWindowTypeDropDownMenu" + , "WA_X11NetWmWindowTypePopupMenu" + , "WA_X11NetWmWindowTypeToolTip" + , "WA_X11NetWmWindowTypeNotification" + , "WA_X11NetWmWindowTypeCombo" + , "WA_X11NetWmWindowTypeDND" + , "WA_MacFrameworkScaled" + , "WA_SetWindowModality" + , "WA_WState_WindowOpacitySet" + , "WA_TranslucentBackground" + , "WA_AttributeCount" +}; + +static QString qtscript_Qt_WidgetAttribute_toStringHelper(Qt::WidgetAttribute value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WidgetAttribute"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_WidgetAttribute_toScriptValue(QScriptEngine *engine, const Qt::WidgetAttribute &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WidgetAttribute_toStringHelper(value)); +} + +static void qtscript_Qt_WidgetAttribute_fromScriptValue(const QScriptValue &value, Qt::WidgetAttribute &out) +{ + out = qvariant_cast<Qt::WidgetAttribute>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WidgetAttribute(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WidgetAttribute"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::WidgetAttribute>(arg)); + return context->throwError(QString::fromLatin1("WidgetAttribute(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WidgetAttribute_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WidgetAttribute value = qscriptvalue_cast<Qt::WidgetAttribute>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WidgetAttribute_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WidgetAttribute value = qscriptvalue_cast<Qt::WidgetAttribute>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WidgetAttribute_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WidgetAttribute_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WidgetAttribute, + qtscript_Qt_WidgetAttribute_valueOf, qtscript_Qt_WidgetAttribute_toString); + qScriptRegisterMetaType<Qt::WidgetAttribute>(engine, qtscript_Qt_WidgetAttribute_toScriptValue, + qtscript_Qt_WidgetAttribute_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 104; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WidgetAttribute_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WidgetAttribute_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::TextFormat +// + +static const Qt::TextFormat qtscript_Qt_TextFormat_values[] = { + Qt::PlainText + , Qt::RichText + , Qt::AutoText + , Qt::LogText +}; + +static const char * const qtscript_Qt_TextFormat_keys[] = { + "PlainText" + , "RichText" + , "AutoText" + , "LogText" +}; + +static QString qtscript_Qt_TextFormat_toStringHelper(Qt::TextFormat value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextFormat"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_TextFormat_toScriptValue(QScriptEngine *engine, const Qt::TextFormat &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_TextFormat_toStringHelper(value)); +} + +static void qtscript_Qt_TextFormat_fromScriptValue(const QScriptValue &value, Qt::TextFormat &out) +{ + out = qvariant_cast<Qt::TextFormat>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_TextFormat(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("TextFormat"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::TextFormat>(arg)); + return context->throwError(QString::fromLatin1("TextFormat(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_TextFormat_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextFormat value = qscriptvalue_cast<Qt::TextFormat>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_TextFormat_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::TextFormat value = qscriptvalue_cast<Qt::TextFormat>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_TextFormat_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_TextFormat_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_TextFormat, + qtscript_Qt_TextFormat_valueOf, qtscript_Qt_TextFormat_toString); + qScriptRegisterMetaType<Qt::TextFormat>(engine, qtscript_Qt_TextFormat_toScriptValue, + qtscript_Qt_TextFormat_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 4; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_TextFormat_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_TextFormat_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::MouseButton +// + +static const Qt::MouseButton qtscript_Qt_MouseButton_values[] = { + Qt::NoButton + , Qt::LeftButton + , Qt::RightButton + , Qt::MidButton + , Qt::XButton1 + , Qt::XButton2 + , Qt::MouseButtonMask +}; + +static const char * const qtscript_Qt_MouseButton_keys[] = { + "NoButton" + , "LeftButton" + , "RightButton" + , "MidButton" + , "XButton1" + , "XButton2" + , "MouseButtonMask" +}; + +static QString qtscript_Qt_MouseButton_toStringHelper(Qt::MouseButton value) +{ + for (int i = 0; i < 7; ++i) { + if (qtscript_Qt_MouseButton_values[i] == value) + return QString::fromLatin1(qtscript_Qt_MouseButton_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_MouseButton_toScriptValue(QScriptEngine *engine, const Qt::MouseButton &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_MouseButton_toStringHelper(value)); +} + +static void qtscript_Qt_MouseButton_fromScriptValue(const QScriptValue &value, Qt::MouseButton &out) +{ + out = qvariant_cast<Qt::MouseButton>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_MouseButton(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 7; ++i) { + if (qtscript_Qt_MouseButton_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::MouseButton>(arg)); + } + return context->throwError(QString::fromLatin1("MouseButton(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_MouseButton_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MouseButton value = qscriptvalue_cast<Qt::MouseButton>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_MouseButton_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MouseButton value = qscriptvalue_cast<Qt::MouseButton>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_MouseButton_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_MouseButton_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_MouseButton, + qtscript_Qt_MouseButton_valueOf, qtscript_Qt_MouseButton_toString); + qScriptRegisterMetaType<Qt::MouseButton>(engine, qtscript_Qt_MouseButton_toScriptValue, + qtscript_Qt_MouseButton_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 7; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_MouseButton_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_MouseButton_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::MouseButtons +// + +static QScriptValue qtscript_Qt_MouseButtons_toScriptValue(QScriptEngine *engine, const Qt::MouseButtons &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_MouseButtons_fromScriptValue(const QScriptValue &value, Qt::MouseButtons &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::MouseButtons>()) + out = qvariant_cast<Qt::MouseButtons>(var); + else if (var.userType() == qMetaTypeId<Qt::MouseButton>()) + out = qvariant_cast<Qt::MouseButton>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_MouseButtons(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MouseButtons result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::MouseButtons>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::MouseButton>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("MouseButtons(): argument %0 is not of type MouseButton").arg(i)); + } + result |= qvariant_cast<Qt::MouseButton>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_MouseButtons_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MouseButtons value = qscriptvalue_cast<Qt::MouseButtons>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_MouseButtons_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::MouseButtons value = qscriptvalue_cast<Qt::MouseButtons>(context->thisObject()); + QString result; + for (int i = 0; i < 7; ++i) { + if ((value & qtscript_Qt_MouseButton_values[i]) == qtscript_Qt_MouseButton_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_MouseButton_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_MouseButtons_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::MouseButtons>() == otherObj.value<Qt::MouseButtons>()))); +} + +static QScriptValue qtscript_create_Qt_MouseButtons_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_MouseButtons, qtscript_Qt_MouseButtons_valueOf, + qtscript_Qt_MouseButtons_toString, qtscript_Qt_MouseButtons_equals); + qScriptRegisterMetaType<Qt::MouseButtons>(engine, qtscript_Qt_MouseButtons_toScriptValue, + qtscript_Qt_MouseButtons_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::WindowState +// + +static const Qt::WindowState qtscript_Qt_WindowState_values[] = { + Qt::WindowNoState + , Qt::WindowMinimized + , Qt::WindowMaximized + , Qt::WindowFullScreen + , Qt::WindowActive +}; + +static const char * const qtscript_Qt_WindowState_keys[] = { + "WindowNoState" + , "WindowMinimized" + , "WindowMaximized" + , "WindowFullScreen" + , "WindowActive" +}; + +static QString qtscript_Qt_WindowState_toStringHelper(Qt::WindowState value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowState"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_WindowState_toScriptValue(QScriptEngine *engine, const Qt::WindowState &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_WindowState_toStringHelper(value)); +} + +static void qtscript_Qt_WindowState_fromScriptValue(const QScriptValue &value, Qt::WindowState &out) +{ + out = qvariant_cast<Qt::WindowState>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_WindowState(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("WindowState"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::WindowState>(arg)); + return context->throwError(QString::fromLatin1("WindowState(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_WindowState_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowState value = qscriptvalue_cast<Qt::WindowState>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowState_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowState value = qscriptvalue_cast<Qt::WindowState>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_WindowState_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_WindowState_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_WindowState, + qtscript_Qt_WindowState_valueOf, qtscript_Qt_WindowState_toString); + qScriptRegisterMetaType<Qt::WindowState>(engine, qtscript_Qt_WindowState_toScriptValue, + qtscript_Qt_WindowState_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 5; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_WindowState_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_WindowState_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::WindowStates +// + +static QScriptValue qtscript_Qt_WindowStates_toScriptValue(QScriptEngine *engine, const Qt::WindowStates &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_WindowStates_fromScriptValue(const QScriptValue &value, Qt::WindowStates &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::WindowStates>()) + out = qvariant_cast<Qt::WindowStates>(var); + else if (var.userType() == qMetaTypeId<Qt::WindowState>()) + out = qvariant_cast<Qt::WindowState>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_WindowStates(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowStates result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::WindowStates>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::WindowState>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("WindowStates(): argument %0 is not of type WindowState").arg(i)); + } + result |= qvariant_cast<Qt::WindowState>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_WindowStates_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowStates value = qscriptvalue_cast<Qt::WindowStates>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_WindowStates_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::WindowStates value = qscriptvalue_cast<Qt::WindowStates>(context->thisObject()); + QString result; + for (int i = 0; i < 5; ++i) { + if ((value & qtscript_Qt_WindowState_values[i]) == qtscript_Qt_WindowState_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_WindowState_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_WindowStates_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::WindowStates>() == otherObj.value<Qt::WindowStates>()))); +} + +static QScriptValue qtscript_create_Qt_WindowStates_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_WindowStates, qtscript_Qt_WindowStates_valueOf, + qtscript_Qt_WindowStates_toString, qtscript_Qt_WindowStates_equals); + qScriptRegisterMetaType<Qt::WindowStates>(engine, qtscript_Qt_WindowStates_toScriptValue, + qtscript_Qt_WindowStates_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::PenStyle +// + +static const Qt::PenStyle qtscript_Qt_PenStyle_values[] = { + Qt::NoPen + , Qt::SolidLine + , Qt::DashLine + , Qt::DotLine + , Qt::DashDotLine + , Qt::DashDotDotLine + , Qt::CustomDashLine + , Qt::MPenStyle +}; + +static const char * const qtscript_Qt_PenStyle_keys[] = { + "NoPen" + , "SolidLine" + , "DashLine" + , "DotLine" + , "DashDotLine" + , "DashDotDotLine" + , "CustomDashLine" + , "MPenStyle" +}; + +static QString qtscript_Qt_PenStyle_toStringHelper(Qt::PenStyle value) +{ + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + return QString::fromLatin1(menum.valueToKey(value)); +} + +static QScriptValue qtscript_Qt_PenStyle_toScriptValue(QScriptEngine *engine, const Qt::PenStyle &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_PenStyle_toStringHelper(value)); +} + +static void qtscript_Qt_PenStyle_fromScriptValue(const QScriptValue &value, Qt::PenStyle &out) +{ + out = qvariant_cast<Qt::PenStyle>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_PenStyle(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + const QMetaObject *meta = qtscript_Qt_metaObject(); + int idx = meta->indexOfEnumerator("PenStyle"); + Q_ASSERT(idx != -1); + QMetaEnum menum = meta->enumerator(idx); + if (menum.valueToKey(arg) != 0) + return qScriptValueFromValue(engine, static_cast<Qt::PenStyle>(arg)); + return context->throwError(QString::fromLatin1("PenStyle(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_PenStyle_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenStyle value = qscriptvalue_cast<Qt::PenStyle>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_PenStyle_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::PenStyle value = qscriptvalue_cast<Qt::PenStyle>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_PenStyle_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_PenStyle_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_PenStyle, + qtscript_Qt_PenStyle_valueOf, qtscript_Qt_PenStyle_toString); + qScriptRegisterMetaType<Qt::PenStyle>(engine, qtscript_Qt_PenStyle_toScriptValue, + qtscript_Qt_PenStyle_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 8; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_PenStyle_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_PenStyle_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ItemFlag +// + +static const Qt::ItemFlag qtscript_Qt_ItemFlag_values[] = { + Qt::NoItemFlags + , Qt::ItemIsSelectable + , Qt::ItemIsEditable + , Qt::ItemIsDragEnabled + , Qt::ItemIsDropEnabled + , Qt::ItemIsUserCheckable + , Qt::ItemIsEnabled + , Qt::ItemIsTristate +}; + +static const char * const qtscript_Qt_ItemFlag_keys[] = { + "NoItemFlags" + , "ItemIsSelectable" + , "ItemIsEditable" + , "ItemIsDragEnabled" + , "ItemIsDropEnabled" + , "ItemIsUserCheckable" + , "ItemIsEnabled" + , "ItemIsTristate" +}; + +static QString qtscript_Qt_ItemFlag_toStringHelper(Qt::ItemFlag value) +{ + for (int i = 0; i < 8; ++i) { + if (qtscript_Qt_ItemFlag_values[i] == value) + return QString::fromLatin1(qtscript_Qt_ItemFlag_keys[i]); + } + return QString(); +} + +static QScriptValue qtscript_Qt_ItemFlag_toScriptValue(QScriptEngine *engine, const Qt::ItemFlag &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_ItemFlag_toStringHelper(value)); +} + +static void qtscript_Qt_ItemFlag_fromScriptValue(const QScriptValue &value, Qt::ItemFlag &out) +{ + out = qvariant_cast<Qt::ItemFlag>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_ItemFlag(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + for (int i = 0; i < 8; ++i) { + if (qtscript_Qt_ItemFlag_values[i] == arg) + return qScriptValueFromValue(engine, static_cast<Qt::ItemFlag>(arg)); + } + return context->throwError(QString::fromLatin1("ItemFlag(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_ItemFlag_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemFlag value = qscriptvalue_cast<Qt::ItemFlag>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ItemFlag_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemFlag value = qscriptvalue_cast<Qt::ItemFlag>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_ItemFlag_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_ItemFlag_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_ItemFlag, + qtscript_Qt_ItemFlag_valueOf, qtscript_Qt_ItemFlag_toString); + qScriptRegisterMetaType<Qt::ItemFlag>(engine, qtscript_Qt_ItemFlag_toScriptValue, + qtscript_Qt_ItemFlag_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 8; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_ItemFlag_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_ItemFlag_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt::ItemFlags +// + +static QScriptValue qtscript_Qt_ItemFlags_toScriptValue(QScriptEngine *engine, const Qt::ItemFlags &value) +{ + return engine->newVariant(qVariantFromValue(value)); +} + +static void qtscript_Qt_ItemFlags_fromScriptValue(const QScriptValue &value, Qt::ItemFlags &out) +{ + QVariant var = value.toVariant(); + if (var.userType() == qMetaTypeId<Qt::ItemFlags>()) + out = qvariant_cast<Qt::ItemFlags>(var); + else if (var.userType() == qMetaTypeId<Qt::ItemFlag>()) + out = qvariant_cast<Qt::ItemFlag>(var); + else + out = 0; +} + +static QScriptValue qtscript_construct_Qt_ItemFlags(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemFlags result = 0; + if ((context->argumentCount() == 1) && context->argument(0).isNumber()) { + result = static_cast<Qt::ItemFlags>(context->argument(0).toInt32()); + } else { + for (int i = 0; i < context->argumentCount(); ++i) { + QVariant v = context->argument(i).toVariant(); + if (v.userType() != qMetaTypeId<Qt::ItemFlag>()) { + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("ItemFlags(): argument %0 is not of type ItemFlag").arg(i)); + } + result |= qvariant_cast<Qt::ItemFlag>(v); + } + } + return engine->newVariant(qVariantFromValue(result)); +} + +static QScriptValue qtscript_Qt_ItemFlags_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemFlags value = qscriptvalue_cast<Qt::ItemFlags>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_ItemFlags_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::ItemFlags value = qscriptvalue_cast<Qt::ItemFlags>(context->thisObject()); + QString result; + for (int i = 0; i < 8; ++i) { + if ((value & qtscript_Qt_ItemFlag_values[i]) == qtscript_Qt_ItemFlag_values[i]) { + if (!result.isEmpty()) + result.append(QString::fromLatin1(",")); + result.append(QString::fromLatin1(qtscript_Qt_ItemFlag_keys[i])); + } + } + return QScriptValue(engine, result); +} + +static QScriptValue qtscript_Qt_ItemFlags_equals(QScriptContext *context, QScriptEngine *engine) +{ + QVariant thisObj = context->thisObject().toVariant(); + QVariant otherObj = context->argument(0).toVariant(); + return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) && + (thisObj.value<Qt::ItemFlags>() == otherObj.value<Qt::ItemFlags>()))); +} + +static QScriptValue qtscript_create_Qt_ItemFlags_class(QScriptEngine *engine) +{ + QScriptValue ctor = qtscript_create_flags_class_helper( + engine, qtscript_construct_Qt_ItemFlags, qtscript_Qt_ItemFlags_valueOf, + qtscript_Qt_ItemFlags_toString, qtscript_Qt_ItemFlags_equals); + qScriptRegisterMetaType<Qt::ItemFlags>(engine, qtscript_Qt_ItemFlags_toScriptValue, + qtscript_Qt_ItemFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + return ctor; +} + +// +// Qt::HitTestAccuracy +// + +static const Qt::HitTestAccuracy qtscript_Qt_HitTestAccuracy_values[] = { + Qt::ExactHit + , Qt::FuzzyHit +}; + +static const char * const qtscript_Qt_HitTestAccuracy_keys[] = { + "ExactHit" + , "FuzzyHit" +}; + +static QString qtscript_Qt_HitTestAccuracy_toStringHelper(Qt::HitTestAccuracy value) +{ + if ((value >= Qt::ExactHit) && (value <= Qt::FuzzyHit)) + return qtscript_Qt_HitTestAccuracy_keys[static_cast<int>(value)-static_cast<int>(Qt::ExactHit)]; + return QString(); +} + +static QScriptValue qtscript_Qt_HitTestAccuracy_toScriptValue(QScriptEngine *engine, const Qt::HitTestAccuracy &value) +{ + QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("Qt")); + return clazz.property(qtscript_Qt_HitTestAccuracy_toStringHelper(value)); +} + +static void qtscript_Qt_HitTestAccuracy_fromScriptValue(const QScriptValue &value, Qt::HitTestAccuracy &out) +{ + out = qvariant_cast<Qt::HitTestAccuracy>(value.toVariant()); +} + +static QScriptValue qtscript_construct_Qt_HitTestAccuracy(QScriptContext *context, QScriptEngine *engine) +{ + int arg = context->argument(0).toInt32(); + if ((arg >= Qt::ExactHit) && (arg <= Qt::FuzzyHit)) + return qScriptValueFromValue(engine, static_cast<Qt::HitTestAccuracy>(arg)); + return context->throwError(QString::fromLatin1("HitTestAccuracy(): invalid enum value (%0)").arg(arg)); +} + +static QScriptValue qtscript_Qt_HitTestAccuracy_valueOf(QScriptContext *context, QScriptEngine *engine) +{ + Qt::HitTestAccuracy value = qscriptvalue_cast<Qt::HitTestAccuracy>(context->thisObject()); + return QScriptValue(engine, static_cast<int>(value)); +} + +static QScriptValue qtscript_Qt_HitTestAccuracy_toString(QScriptContext *context, QScriptEngine *engine) +{ + Qt::HitTestAccuracy value = qscriptvalue_cast<Qt::HitTestAccuracy>(context->thisObject()); + return QScriptValue(engine, qtscript_Qt_HitTestAccuracy_toStringHelper(value)); +} + +static QScriptValue qtscript_create_Qt_HitTestAccuracy_class(QScriptEngine *engine, QScriptValue &clazz) +{ + QScriptValue ctor = qtscript_create_enum_class_helper( + engine, qtscript_construct_Qt_HitTestAccuracy, + qtscript_Qt_HitTestAccuracy_valueOf, qtscript_Qt_HitTestAccuracy_toString); + qScriptRegisterMetaType<Qt::HitTestAccuracy>(engine, qtscript_Qt_HitTestAccuracy_toScriptValue, + qtscript_Qt_HitTestAccuracy_fromScriptValue, ctor.property(QString::fromLatin1("prototype"))); + for (int i = 0; i < 2; ++i) { + clazz.setProperty(QString::fromLatin1(qtscript_Qt_HitTestAccuracy_keys[i]), + engine->newVariant(qVariantFromValue(qtscript_Qt_HitTestAccuracy_values[i])), + QScriptValue::ReadOnly | QScriptValue::Undeletable); + } + return ctor; +} + +// +// Qt +// + +static QScriptValue qtscript_Qt_static_call(QScriptContext *context, QScriptEngine *) +{ + uint _id = context->callee().data().toUInt32(); + Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000); + _id &= 0x0000FFFF; + switch (_id) { + case 0: + return context->throwError(QScriptContext::TypeError, + QString::fromLatin1("Qt cannot be constructed")); + break; + + default: + Q_ASSERT(false); + } + return qtscript_Qt_throw_ambiguity_error_helper(context, + qtscript_Qt_function_names[_id], + qtscript_Qt_function_signatures[_id]); +} + +QScriptValue qtscript_create_Qt_class(QScriptEngine *engine) +{ + static const int function_lengths[] = { + 0 + // static + // prototype + , 0 + }; + QScriptValue proto = QScriptValue(); + QScriptValue ctor = engine->newFunction(qtscript_Qt_static_call, proto, function_lengths[0]); + ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0))); + + ctor.setProperty(QString::fromLatin1("CursorShape"), + qtscript_create_Qt_CursorShape_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Corner"), + qtscript_create_Qt_Corner_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Axis"), + qtscript_create_Qt_Axis_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Orientation"), + qtscript_create_Qt_Orientation_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Orientations"), + qtscript_create_Qt_Orientations_class(engine)); + ctor.setProperty(QString::fromLatin1("LayoutDirection"), + qtscript_create_Qt_LayoutDirection_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("BGMode"), + qtscript_create_Qt_BGMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("AspectRatioMode"), + qtscript_create_Qt_AspectRatioMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TextElideMode"), + qtscript_create_Qt_TextElideMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("SizeMode"), + qtscript_create_Qt_SizeMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("WindowType"), + qtscript_create_Qt_WindowType_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("WindowFlags"), + qtscript_create_Qt_WindowFlags_class(engine)); + ctor.setProperty(QString::fromLatin1("ItemDataRole"), + qtscript_create_Qt_ItemDataRole_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("SortOrder"), + qtscript_create_Qt_SortOrder_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("MatchFlag"), + qtscript_create_Qt_MatchFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("MatchFlags"), + qtscript_create_Qt_MatchFlags_class(engine)); + ctor.setProperty(QString::fromLatin1("PenJoinStyle"), + qtscript_create_Qt_PenJoinStyle_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("CaseSensitivity"), + qtscript_create_Qt_CaseSensitivity_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("BrushStyle"), + qtscript_create_Qt_BrushStyle_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ClipOperation"), + qtscript_create_Qt_ClipOperation_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("FocusReason"), + qtscript_create_Qt_FocusReason_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ToolBarArea"), + qtscript_create_Qt_ToolBarArea_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ToolBarAreas"), + qtscript_create_Qt_ToolBarAreas_class(engine)); + ctor.setProperty(QString::fromLatin1("KeyboardModifier"), + qtscript_create_Qt_KeyboardModifier_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("KeyboardModifiers"), + qtscript_create_Qt_KeyboardModifiers_class(engine)); + ctor.setProperty(QString::fromLatin1("WhiteSpaceMode"), + qtscript_create_Qt_WhiteSpaceMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DayOfWeek"), + qtscript_create_Qt_DayOfWeek_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("EventPriority"), + qtscript_create_Qt_EventPriority_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DateFormat"), + qtscript_create_Qt_DateFormat_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("MaskMode"), + qtscript_create_Qt_MaskMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("UIEffect"), + qtscript_create_Qt_UIEffect_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ContextMenuPolicy"), + qtscript_create_Qt_ContextMenuPolicy_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("AnchorAttribute"), + qtscript_create_Qt_AnchorAttribute_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ScrollBarPolicy"), + qtscript_create_Qt_ScrollBarPolicy_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ToolButtonStyle"), + qtscript_create_Qt_ToolButtonStyle_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TextFlag"), + qtscript_create_Qt_TextFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ItemSelectionMode"), + qtscript_create_Qt_ItemSelectionMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("SizeHint"), + qtscript_create_Qt_SizeHint_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Key"), + qtscript_create_Qt_Key_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ToolBarAreaSizes"), + qtscript_create_Qt_ToolBarAreaSizes_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ArrowType"), + qtscript_create_Qt_ArrowType_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("FocusPolicy"), + qtscript_create_Qt_FocusPolicy_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("WindowFrameSection"), + qtscript_create_Qt_WindowFrameSection_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("InputMethodQuery"), + qtscript_create_Qt_InputMethodQuery_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DropAction"), + qtscript_create_Qt_DropAction_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DropActions"), + qtscript_create_Qt_DropActions_class(engine)); + ctor.setProperty(QString::fromLatin1("FillRule"), + qtscript_create_Qt_FillRule_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("GlobalColor"), + qtscript_create_Qt_GlobalColor_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ConnectionType"), + qtscript_create_Qt_ConnectionType_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("PenCapStyle"), + qtscript_create_Qt_PenCapStyle_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TransformationMode"), + qtscript_create_Qt_TransformationMode_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DockWidgetAreaSizes"), + qtscript_create_Qt_DockWidgetAreaSizes_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ApplicationAttribute"), + qtscript_create_Qt_ApplicationAttribute_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ShortcutContext"), + qtscript_create_Qt_ShortcutContext_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TextInteractionFlag"), + qtscript_create_Qt_TextInteractionFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TextInteractionFlags"), + qtscript_create_Qt_TextInteractionFlags_class(engine)); + ctor.setProperty(QString::fromLatin1("CheckState"), + qtscript_create_Qt_CheckState_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DockWidgetArea"), + qtscript_create_Qt_DockWidgetArea_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("DockWidgetAreas"), + qtscript_create_Qt_DockWidgetAreas_class(engine)); + ctor.setProperty(QString::fromLatin1("TimeSpec"), + qtscript_create_Qt_TimeSpec_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ImageConversionFlag"), + qtscript_create_Qt_ImageConversionFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ImageConversionFlags"), + qtscript_create_Qt_ImageConversionFlags_class(engine)); + ctor.setProperty(QString::fromLatin1("WindowModality"), + qtscript_create_Qt_WindowModality_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Modifier"), + qtscript_create_Qt_Modifier_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("AlignmentFlag"), + qtscript_create_Qt_AlignmentFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("Alignment"), + qtscript_create_Qt_Alignment_class(engine)); + ctor.setProperty(QString::fromLatin1("WidgetAttribute"), + qtscript_create_Qt_WidgetAttribute_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("TextFormat"), + qtscript_create_Qt_TextFormat_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("MouseButton"), + qtscript_create_Qt_MouseButton_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("MouseButtons"), + qtscript_create_Qt_MouseButtons_class(engine)); + ctor.setProperty(QString::fromLatin1("WindowState"), + qtscript_create_Qt_WindowState_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("WindowStates"), + qtscript_create_Qt_WindowStates_class(engine)); + ctor.setProperty(QString::fromLatin1("PenStyle"), + qtscript_create_Qt_PenStyle_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ItemFlag"), + qtscript_create_Qt_ItemFlag_class(engine, ctor)); + ctor.setProperty(QString::fromLatin1("ItemFlags"), + qtscript_create_Qt_ItemFlags_class(engine)); + ctor.setProperty(QString::fromLatin1("HitTestAccuracy"), + qtscript_create_Qt_HitTestAccuracy_class(engine, ctor)); + return ctor; +} |