add missing qmlRegisterType function

bluetooth/bluetooth.cpp

@@ -127,8 +127,8 @@ unsigned long long QBluetoothAddress_ToUInt64(void* ptr)
 class MyQBluetoothDeviceDiscoveryAgent: public QBluetoothDeviceDiscoveryAgent
 {
 public:
-	MyQBluetoothDeviceDiscoveryAgent(QObject *parent) : QBluetoothDeviceDiscoveryAgent(parent) {};
+	MyQBluetoothDeviceDiscoveryAgent(QObject *parent = Q_NULLPTR) : QBluetoothDeviceDiscoveryAgent(parent) {};
-	MyQBluetoothDeviceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent) : QBluetoothDeviceDiscoveryAgent(deviceAdapter, parent) {};
+	MyQBluetoothDeviceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent = Q_NULLPTR) : QBluetoothDeviceDiscoveryAgent(deviceAdapter, parent) {};
 	void Signal_Canceled() { callbackQBluetoothDeviceDiscoveryAgent_Canceled(this); };
 	void Signal_DeviceDiscovered(const QBluetoothDeviceInfo & info) { callbackQBluetoothDeviceDiscoveryAgent_DeviceDiscovered(this, const_cast<QBluetoothDeviceInfo*>(&info)); };
 	void Signal_Error2(QBluetoothDeviceDiscoveryAgent::Error error) { callbackQBluetoothDeviceDiscoveryAgent_Error2(this, error); };
@@ -679,8 +679,8 @@ struct QtBluetooth_PackedString QBluetoothHostInfo_Name(void* ptr)
 class MyQBluetoothLocalDevice: public QBluetoothLocalDevice
 {
 public:
-	MyQBluetoothLocalDevice(QObject *parent) : QBluetoothLocalDevice(parent) {};
+	MyQBluetoothLocalDevice(QObject *parent = Q_NULLPTR) : QBluetoothLocalDevice(parent) {};
-	MyQBluetoothLocalDevice(const QBluetoothAddress &address, QObject *parent) : QBluetoothLocalDevice(address, parent) {};
+	MyQBluetoothLocalDevice(const QBluetoothAddress &address, QObject *parent = Q_NULLPTR) : QBluetoothLocalDevice(address, parent) {};
 	void Signal_DeviceConnected(const QBluetoothAddress & address) { callbackQBluetoothLocalDevice_DeviceConnected(this, const_cast<QBluetoothAddress*>(&address)); };
 	void Signal_DeviceDisconnected(const QBluetoothAddress & address) { callbackQBluetoothLocalDevice_DeviceDisconnected(this, const_cast<QBluetoothAddress*>(&address)); };
 	void Signal_Error(QBluetoothLocalDevice::Error error) { callbackQBluetoothLocalDevice_Error(this, error); };
@@ -1113,7 +1113,7 @@ void* QBluetoothLocalDevice_MetaObjectDefault(void* ptr)
 class MyQBluetoothServer: public QBluetoothServer
 {
 public:
-	MyQBluetoothServer(QBluetoothServiceInfo::Protocol serverType, QObject *parent) : QBluetoothServer(serverType, parent) {};
+	MyQBluetoothServer(QBluetoothServiceInfo::Protocol serverType, QObject *parent = Q_NULLPTR) : QBluetoothServer(serverType, parent) {};
 	void Signal_Error2(QBluetoothServer::Error error) { callbackQBluetoothServer_Error2(this, error); };
 	void Signal_NewConnection() { callbackQBluetoothServer_NewConnection(this); };
 	bool event(QEvent * e) { return callbackQBluetoothServer_Event(this, e) != 0; };
@@ -1398,8 +1398,8 @@ void* QBluetoothServer_MetaObjectDefault(void* ptr)
 class MyQBluetoothServiceDiscoveryAgent: public QBluetoothServiceDiscoveryAgent
 {
 public:
-	MyQBluetoothServiceDiscoveryAgent(QObject *parent) : QBluetoothServiceDiscoveryAgent(parent) {};
+	MyQBluetoothServiceDiscoveryAgent(QObject *parent = Q_NULLPTR) : QBluetoothServiceDiscoveryAgent(parent) {};
-	MyQBluetoothServiceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent) : QBluetoothServiceDiscoveryAgent(deviceAdapter, parent) {};
+	MyQBluetoothServiceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent = Q_NULLPTR) : QBluetoothServiceDiscoveryAgent(deviceAdapter, parent) {};
 	void Signal_Canceled() { callbackQBluetoothServiceDiscoveryAgent_Canceled(this); };
 	void clear() { callbackQBluetoothServiceDiscoveryAgent_Clear(this); };
 	void Signal_Error2(QBluetoothServiceDiscoveryAgent::Error error) { callbackQBluetoothServiceDiscoveryAgent_Error2(this, error); };
@@ -1985,8 +1985,8 @@ void* QBluetoothServiceInfo___serviceClassUuids_newList(void* ptr)
 class MyQBluetoothSocket: public QBluetoothSocket
 {
 public:
-	MyQBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject *parent) : QBluetoothSocket(socketType, parent) {};
+	MyQBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject *parent = Q_NULLPTR) : QBluetoothSocket(socketType, parent) {};
-	MyQBluetoothSocket(QObject *parent) : QBluetoothSocket(parent) {};
+	MyQBluetoothSocket(QObject *parent = Q_NULLPTR) : QBluetoothSocket(parent) {};
 	void Signal_Connected() { callbackQBluetoothSocket_Connected(this); };
 	void Signal_Disconnected() { callbackQBluetoothSocket_Disconnected(this); };
 	void Signal_Error2(QBluetoothSocket::SocketError error) { callbackQBluetoothSocket_Error2(this, error); };
@@ -2497,7 +2497,7 @@ void* QBluetoothSocket_MetaObjectDefault(void* ptr)
 class MyQBluetoothTransferManager: public QBluetoothTransferManager
 {
 public:
-	MyQBluetoothTransferManager(QObject *parent) : QBluetoothTransferManager(parent) {};
+	MyQBluetoothTransferManager(QObject *parent = Q_NULLPTR) : QBluetoothTransferManager(parent) {};
 	void Signal_Finished(QBluetoothTransferReply * reply) { callbackQBluetoothTransferManager_Finished(this, reply); };
 	bool event(QEvent * e) { return callbackQBluetoothTransferManager_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQBluetoothTransferManager_EventFilter(this, watched, event) != 0; };
@@ -2701,7 +2701,7 @@ void* QBluetoothTransferManager_MetaObjectDefault(void* ptr)
 class MyQBluetoothTransferReply: public QBluetoothTransferReply
 {
 public:
-	MyQBluetoothTransferReply(QObject *parent) : QBluetoothTransferReply(parent) {};
+	MyQBluetoothTransferReply(QObject *parent = Q_NULLPTR) : QBluetoothTransferReply(parent) {};
 	void abort() { callbackQBluetoothTransferReply_Abort(this); };
 	void Signal_Error2(QBluetoothTransferReply::TransferError errorType) { callbackQBluetoothTransferReply_Error2(this, errorType); };
 	void Signal_Finished(QBluetoothTransferReply * reply) { callbackQBluetoothTransferReply_Finished(this, reply); };

charts/charts.cpp

@@ -1496,8 +1496,8 @@ void QAreaLegendMarker_DestroyQAreaLegendMarkerDefault(void* ptr)
 class MyQAreaSeries: public QAreaSeries
 {
 public:
-	MyQAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries) : QAreaSeries(upperSeries, lowerSeries) {};
+	MyQAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries = Q_NULLPTR) : QAreaSeries(upperSeries, lowerSeries) {};
-	MyQAreaSeries(QObject *parent) : QAreaSeries(parent) {};
+	MyQAreaSeries(QObject *parent = Q_NULLPTR) : QAreaSeries(parent) {};
 	void Signal_BorderColorChanged(QColor color) { callbackQAreaSeries_BorderColorChanged(this, new QColor(color)); };
 	void Signal_Clicked(const QPointF & point) { callbackQAreaSeries_Clicked(this, const_cast<QPointF*>(&point)); };
 	void Signal_ColorChanged(QColor color) { callbackQAreaSeries_ColorChanged(this, new QColor(color)); };
@@ -1881,7 +1881,7 @@ char QAreaSeries_PointsVisible(void* ptr)
 class MyQBarCategoryAxis: public QBarCategoryAxis
 {
 public:
-	MyQBarCategoryAxis(QObject *parent) : QBarCategoryAxis(parent) {};
+	MyQBarCategoryAxis(QObject *parent = Q_NULLPTR) : QBarCategoryAxis(parent) {};
 	void Signal_CategoriesChanged() { callbackQBarCategoryAxis_CategoriesChanged(this); };
 	void Signal_CountChanged() { callbackQBarCategoryAxis_CountChanged(this); };
 	void Signal_MaxChanged(const QString & max) { QByteArray t070602 = max.toUtf8(); QtCharts_PackedString maxPacked = { const_cast<char*>(t070602.prepend("WHITESPACE").constData()+10), t070602.size()-10 };callbackQBarCategoryAxis_MaxChanged(this, maxPacked); };
@@ -2175,7 +2175,7 @@ void QBarLegendMarker_DestroyQBarLegendMarkerDefault(void* ptr)
 class MyQBarSeries: public QBarSeries
 {
 public:
-	MyQBarSeries(QObject *parent) : QBarSeries(parent) {};
+	MyQBarSeries(QObject *parent = Q_NULLPTR) : QBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -2254,7 +2254,7 @@ long long QBarSeries_TypeDefault(void* ptr)
 class MyQBarSet: public QBarSet
 {
 public:
-	MyQBarSet(const QString label, QObject *parent) : QBarSet(label, parent) {};
+	MyQBarSet(const QString label, QObject *parent = Q_NULLPTR) : QBarSet(label, parent) {};
 	void Signal_BorderColorChanged(QColor color) { callbackQBarSet_BorderColorChanged(this, new QColor(color)); };
 	void Signal_BrushChanged() { callbackQBarSet_BrushChanged(this); };
 	void Signal_Clicked(int index) { callbackQBarSet_Clicked(this, index); };
@@ -2749,7 +2749,7 @@ void QBoxPlotLegendMarker_DestroyQBoxPlotLegendMarkerDefault(void* ptr)
 class MyQBoxPlotSeries: public QBoxPlotSeries
 {
 public:
-	MyQBoxPlotSeries(QObject *parent) : QBoxPlotSeries(parent) {};
+	MyQBoxPlotSeries(QObject *parent = Q_NULLPTR) : QBoxPlotSeries(parent) {};
 	void Signal_BoxOutlineVisibilityChanged() { callbackQBoxPlotSeries_BoxOutlineVisibilityChanged(this); };
 	void Signal_BoxWidthChanged() { callbackQBoxPlotSeries_BoxWidthChanged(this); };
 	void Signal_BoxsetsAdded(QList<QBoxSet *> sets) { callbackQBoxPlotSeries_BoxsetsAdded(this, ({ QList<QBoxSet *>* tmpValue = new QList<QBoxSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -3148,8 +3148,8 @@ void* QBoxPlotSeries___boxSets_newList(void* ptr)
 class MyQBoxSet: public QBoxSet
 {
 public:
-	MyQBoxSet(const QString label, QObject *parent) : QBoxSet(label, parent) {};
+	MyQBoxSet(const QString label = QString(), QObject *parent = Q_NULLPTR) : QBoxSet(label, parent) {};
-	MyQBoxSet(const qreal le, const qreal lq, const qreal m, const qreal uq, const qreal ue, const QString label, QObject *parent) : QBoxSet(le, lq, m, uq, ue, label, parent) {};
+	MyQBoxSet(const qreal le, const qreal lq, const qreal m, const qreal uq, const qreal ue, const QString label = QString(), QObject *parent = Q_NULLPTR) : QBoxSet(le, lq, m, uq, ue, label, parent) {};
 	void Signal_BrushChanged() { callbackQBoxSet_BrushChanged(this); };
 	void Signal_Cleared() { callbackQBoxSet_Cleared(this); };
 	void Signal_Clicked() { callbackQBoxSet_Clicked(this); };
@@ -3529,7 +3529,7 @@ void QCandlestickLegendMarker_DestroyQCandlestickLegendMarkerDefault(void* ptr)
 class MyQCandlestickModelMapper: public QCandlestickModelMapper
 {
 public:
-	MyQCandlestickModelMapper(QObject *parent) : QCandlestickModelMapper(parent) {};
+	MyQCandlestickModelMapper(QObject *parent = nullptr) : QCandlestickModelMapper(parent) {};
 	void Signal_ModelReplaced() { callbackQCandlestickModelMapper_ModelReplaced(this); };
 	void Signal_SeriesReplaced() { callbackQCandlestickModelMapper_SeriesReplaced(this); };
 	Qt::Orientation orientation() const { return static_cast<Qt::Orientation>(callbackQCandlestickModelMapper_Orientation(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -3704,7 +3704,7 @@ int QCandlestickModelMapper_Timestamp(void* ptr)
 class MyQCandlestickSeries: public QCandlestickSeries
 {
 public:
-	MyQCandlestickSeries(QObject *parent) : QCandlestickSeries(parent) {};
+	MyQCandlestickSeries(QObject *parent = nullptr) : QCandlestickSeries(parent) {};
 	void Signal_BodyOutlineVisibilityChanged() { callbackQCandlestickSeries_BodyOutlineVisibilityChanged(this); };
 	void Signal_BodyWidthChanged() { callbackQCandlestickSeries_BodyWidthChanged(this); };
 	void Signal_BrushChanged() { callbackQCandlestickSeries_BrushChanged(this); };
@@ -4279,8 +4279,8 @@ void* QCandlestickSeries___sets_newList(void* ptr)
 class MyQCandlestickSet: public QCandlestickSet
 {
 public:
-	MyQCandlestickSet(qreal open, qreal high, qreal low, qreal close, qreal timestamp, QObject *parent) : QCandlestickSet(open, high, low, close, timestamp, parent) {};
+	MyQCandlestickSet(qreal open, qreal high, qreal low, qreal close, qreal timestamp = 0.0, QObject *parent = nullptr) : QCandlestickSet(open, high, low, close, timestamp, parent) {};
-	MyQCandlestickSet(qreal timestamp, QObject *parent) : QCandlestickSet(timestamp, parent) {};
+	MyQCandlestickSet(qreal timestamp = 0.0, QObject *parent = nullptr) : QCandlestickSet(timestamp, parent) {};
 	void Signal_BrushChanged() { callbackQCandlestickSet_BrushChanged(this); };
 	void Signal_Clicked() { callbackQCandlestickSet_Clicked(this); };
 	void Signal_CloseChanged() { callbackQCandlestickSet_CloseChanged(this); };
@@ -4641,7 +4641,7 @@ double QCandlestickSet_Timestamp(void* ptr)
 class MyQCategoryAxis: public QCategoryAxis
 {
 public:
-	MyQCategoryAxis(QObject *parent) : QCategoryAxis(parent) {};
+	MyQCategoryAxis(QObject *parent = Q_NULLPTR) : QCategoryAxis(parent) {};
 	void Signal_CategoriesChanged() { callbackQCategoryAxis_CategoriesChanged(this); };
 	void Signal_LabelsPositionChanged(QCategoryAxis::AxisLabelsPosition position) { callbackQCategoryAxis_LabelsPositionChanged(this, position); };
 	AxisType type() const { return static_cast<QAbstractAxis::AxisType>(callbackQValueAxis_Type(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -4808,7 +4808,7 @@ double QCategoryAxis_StartValue(void* ptr, char* categoryLabel)
 class MyQChart: public QChart
 {
 public:
-	MyQChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QChart(parent, wFlags) {};
+	MyQChart(QGraphicsItem *parent = Q_NULLPTR, Qt::WindowFlags wFlags = Qt::WindowFlags()) : QChart(parent, wFlags) {};
 	void Signal_PlotAreaChanged(const QRectF & plotArea) { callbackQChart_PlotAreaChanged(this, const_cast<QRectF*>(&plotArea)); };
 	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQChart_ItemChange(this, change, const_cast<QVariant*>(&value))); };
 	bool close() { return callbackQChart_Close(this) != 0; };
@@ -5998,8 +5998,8 @@ char QChart_IsObscuredByDefault(void* ptr, void* item)
 class MyQChartView: public QChartView
 {
 public:
-	MyQChartView(QChart *chart, QWidget *parent) : QChartView(chart, parent) {};
+	MyQChartView(QChart *chart, QWidget *parent = Q_NULLPTR) : QChartView(chart, parent) {};
-	MyQChartView(QWidget *parent) : QChartView(parent) {};
+	MyQChartView(QWidget *parent = Q_NULLPTR) : QChartView(parent) {};
 	void mouseMoveEvent(QMouseEvent * event) { callbackQChartView_MouseMoveEvent(this, event); };
 	void mousePressEvent(QMouseEvent * event) { callbackQChartView_MousePressEvent(this, event); };
 	void mouseReleaseEvent(QMouseEvent * event) { callbackQChartView_MouseReleaseEvent(this, event); };
@@ -6739,7 +6739,7 @@ void* QChartView_MetaObjectDefault(void* ptr)
 class MyQDateTimeAxis: public QDateTimeAxis
 {
 public:
-	MyQDateTimeAxis(QObject *parent) : QDateTimeAxis(parent) {};
+	MyQDateTimeAxis(QObject *parent = Q_NULLPTR) : QDateTimeAxis(parent) {};
 	void Signal_FormatChanged(QString format) { QByteArray t785987 = format.toUtf8(); QtCharts_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQDateTimeAxis_FormatChanged(this, formatPacked); };
 	void Signal_MaxChanged(QDateTime max) { callbackQDateTimeAxis_MaxChanged(this, new QDateTime(max)); };
 	void Signal_MinChanged(QDateTime min) { callbackQDateTimeAxis_MinChanged(this, new QDateTime(min)); };
@@ -6952,7 +6952,7 @@ int QDateTimeAxis_TickCount(void* ptr)
 class MyQHBarModelMapper: public QHBarModelMapper
 {
 public:
-	MyQHBarModelMapper(QObject *parent) : QHBarModelMapper(parent) {};
+	MyQHBarModelMapper(QObject *parent = Q_NULLPTR) : QHBarModelMapper(parent) {};
 	void Signal_ColumnCountChanged() { callbackQHBarModelMapper_ColumnCountChanged(this); };
 	void Signal_FirstBarSetRowChanged() { callbackQHBarModelMapper_FirstBarSetRowChanged(this); };
 	void Signal_FirstColumnChanged() { callbackQHBarModelMapper_FirstColumnChanged(this); };
@@ -7155,7 +7155,7 @@ int QHBarModelMapper_LastBarSetRow(void* ptr)
 class MyQHBoxPlotModelMapper: public QHBoxPlotModelMapper
 {
 public:
-	MyQHBoxPlotModelMapper(QObject *parent) : QHBoxPlotModelMapper(parent) {};
+	MyQHBoxPlotModelMapper(QObject *parent = nullptr) : QHBoxPlotModelMapper(parent) {};
 	void Signal_ColumnCountChanged() { callbackQHBoxPlotModelMapper_ColumnCountChanged(this); };
 	void Signal_FirstBoxSetRowChanged() { callbackQHBoxPlotModelMapper_FirstBoxSetRowChanged(this); };
 	void Signal_FirstColumnChanged() { callbackQHBoxPlotModelMapper_FirstColumnChanged(this); };
@@ -7358,7 +7358,7 @@ int QHBoxPlotModelMapper_LastBoxSetRow(void* ptr)
 class MyQHCandlestickModelMapper: public QHCandlestickModelMapper
 {
 public:
-	MyQHCandlestickModelMapper(QObject *parent) : QHCandlestickModelMapper(parent) {};
+	MyQHCandlestickModelMapper(QObject *parent = nullptr) : QHCandlestickModelMapper(parent) {};
 	void Signal_CloseColumnChanged() { callbackQHCandlestickModelMapper_CloseColumnChanged(this); };
 	void Signal_FirstSetRowChanged() { callbackQHCandlestickModelMapper_FirstSetRowChanged(this); };
 	void Signal_HighColumnChanged() { callbackQHCandlestickModelMapper_HighColumnChanged(this); };
@@ -7600,7 +7600,7 @@ int QHCandlestickModelMapper_TimestampColumn(void* ptr)
 class MyQHPieModelMapper: public QHPieModelMapper
 {
 public:
-	MyQHPieModelMapper(QObject *parent) : QHPieModelMapper(parent) {};
+	MyQHPieModelMapper(QObject *parent = Q_NULLPTR) : QHPieModelMapper(parent) {};
 	void Signal_ColumnCountChanged() { callbackQHPieModelMapper_ColumnCountChanged(this); };
 	void Signal_FirstColumnChanged() { callbackQHPieModelMapper_FirstColumnChanged(this); };
 	void Signal_LabelsRowChanged() { callbackQHPieModelMapper_LabelsRowChanged(this); };
@@ -7803,7 +7803,7 @@ int QHPieModelMapper_ValuesRow(void* ptr)
 class MyQHXYModelMapper: public QHXYModelMapper
 {
 public:
-	MyQHXYModelMapper(QObject *parent) : QHXYModelMapper(parent) {};
+	MyQHXYModelMapper(QObject *parent = Q_NULLPTR) : QHXYModelMapper(parent) {};
 	void Signal_ColumnCountChanged() { callbackQHXYModelMapper_ColumnCountChanged(this); };
 	void Signal_FirstColumnChanged() { callbackQHXYModelMapper_FirstColumnChanged(this); };
 	void Signal_ModelReplaced() { callbackQHXYModelMapper_ModelReplaced(this); };
@@ -8006,7 +8006,7 @@ int QHXYModelMapper_YRow(void* ptr)
 class MyQHorizontalBarSeries: public QHorizontalBarSeries
 {
 public:
-	MyQHorizontalBarSeries(QObject *parent) : QHorizontalBarSeries(parent) {};
+	MyQHorizontalBarSeries(QObject *parent = Q_NULLPTR) : QHorizontalBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQHorizontalBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -8085,7 +8085,7 @@ long long QHorizontalBarSeries_TypeDefault(void* ptr)
 class MyQHorizontalPercentBarSeries: public QHorizontalPercentBarSeries
 {
 public:
-	MyQHorizontalPercentBarSeries(QObject *parent) : QHorizontalPercentBarSeries(parent) {};
+	MyQHorizontalPercentBarSeries(QObject *parent = Q_NULLPTR) : QHorizontalPercentBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQHorizontalPercentBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -8164,7 +8164,7 @@ long long QHorizontalPercentBarSeries_TypeDefault(void* ptr)
 class MyQHorizontalStackedBarSeries: public QHorizontalStackedBarSeries
 {
 public:
-	MyQHorizontalStackedBarSeries(QObject *parent) : QHorizontalStackedBarSeries(parent) {};
+	MyQHorizontalStackedBarSeries(QObject *parent = Q_NULLPTR) : QHorizontalStackedBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQHorizontalStackedBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -9286,7 +9286,7 @@ char QLegendMarker_IsVisible(void* ptr)
 class MyQLineSeries: public QLineSeries
 {
 public:
-	MyQLineSeries(QObject *parent) : QLineSeries(parent) {};
+	MyQLineSeries(QObject *parent = Q_NULLPTR) : QLineSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQLineSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_Clicked(const QPointF & point) { callbackQXYSeries_Clicked(this, const_cast<QPointF*>(&point)); };
 	void Signal_ColorChanged(QColor color) { callbackQXYSeries_ColorChanged(this, new QColor(color)); };
@@ -9378,7 +9378,7 @@ long long QLineSeries_TypeDefault(void* ptr)
 class MyQLogValueAxis: public QLogValueAxis
 {
 public:
-	MyQLogValueAxis(QObject *parent) : QLogValueAxis(parent) {};
+	MyQLogValueAxis(QObject *parent = Q_NULLPTR) : QLogValueAxis(parent) {};
 	void Signal_BaseChanged(qreal base) { callbackQLogValueAxis_BaseChanged(this, base); };
 	void Signal_LabelFormatChanged(const QString & format) { QByteArray t785987 = format.toUtf8(); QtCharts_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQLogValueAxis_LabelFormatChanged(this, formatPacked); };
 	void Signal_MaxChanged(qreal max) { callbackQLogValueAxis_MaxChanged(this, max); };
@@ -9591,7 +9591,7 @@ double QLogValueAxis_Min(void* ptr)
 class MyQPercentBarSeries: public QPercentBarSeries
 {
 public:
-	MyQPercentBarSeries(QObject *parent) : QPercentBarSeries(parent) {};
+	MyQPercentBarSeries(QObject *parent = Q_NULLPTR) : QPercentBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQPercentBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -9721,7 +9721,7 @@ void QPieLegendMarker_DestroyQPieLegendMarkerDefault(void* ptr)
 class MyQPieSeries: public QPieSeries
 {
 public:
-	MyQPieSeries(QObject *parent) : QPieSeries(parent) {};
+	MyQPieSeries(QObject *parent = Q_NULLPTR) : QPieSeries(parent) {};
 	void Signal_Added(QList<QPieSlice *> slices) { callbackQPieSeries_Added(this, ({ QList<QPieSlice *>* tmpValue = new QList<QPieSlice *>(slices); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_Clicked(QPieSlice * slice) { callbackQPieSeries_Clicked(this, slice); };
 	void Signal_CountChanged() { callbackQPieSeries_CountChanged(this); };
@@ -10123,8 +10123,8 @@ void* QPieSeries___slices_newList(void* ptr)
 class MyQPieSlice: public QPieSlice
 {
 public:
-	MyQPieSlice(QObject *parent) : QPieSlice(parent) {};
+	MyQPieSlice(QObject *parent = Q_NULLPTR) : QPieSlice(parent) {};
-	MyQPieSlice(QString label, qreal value, QObject *parent) : QPieSlice(label, value, parent) {};
+	MyQPieSlice(QString label, qreal value, QObject *parent = Q_NULLPTR) : QPieSlice(label, value, parent) {};
 	void Signal_AngleSpanChanged() { callbackQPieSlice_AngleSpanChanged(this); };
 	void Signal_BorderColorChanged() { callbackQPieSlice_BorderColorChanged(this); };
 	void Signal_BorderWidthChanged() { callbackQPieSlice_BorderWidthChanged(this); };
@@ -10697,7 +10697,7 @@ double QPieSlice_Value(void* ptr)
 class MyQPolarChart: public QPolarChart
 {
 public:
-	MyQPolarChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QPolarChart(parent, wFlags) {};
+	MyQPolarChart(QGraphicsItem *parent = Q_NULLPTR, Qt::WindowFlags wFlags = Qt::WindowFlags()) : QPolarChart(parent, wFlags) {};
 	void Signal_PlotAreaChanged(const QRectF & plotArea) { callbackQChart_PlotAreaChanged(this, const_cast<QRectF*>(&plotArea)); };
 	QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant & value) { return *static_cast<QVariant*>(callbackQChart_ItemChange(this, change, const_cast<QVariant*>(&value))); };
 	bool close() { return callbackQChart_Close(this) != 0; };
@@ -10810,7 +10810,7 @@ struct QtCharts_PackedList QPolarChart_Axes(void* ptr, long long polarOrientatio
 class MyQScatterSeries: public QScatterSeries
 {
 public:
-	MyQScatterSeries(QObject *parent) : QScatterSeries(parent) {};
+	MyQScatterSeries(QObject *parent = Q_NULLPTR) : QScatterSeries(parent) {};
 	void Signal_BorderColorChanged(QColor color) { callbackQScatterSeries_BorderColorChanged(this, new QColor(color)); };
 	void Signal_ColorChanged(QColor color) { callbackQXYSeries_ColorChanged(this, new QColor(color)); };
 	void Signal_MarkerShapeChanged(QScatterSeries::MarkerShape shape) { callbackQScatterSeries_MarkerShapeChanged(this, shape); };
@@ -10976,7 +10976,7 @@ double QScatterSeries_MarkerSize(void* ptr)
 class MyQSplineSeries: public QSplineSeries
 {
 public:
-	MyQSplineSeries(QObject *parent) : QSplineSeries(parent) {};
+	MyQSplineSeries(QObject *parent = Q_NULLPTR) : QSplineSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQLineSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_Clicked(const QPointF & point) { callbackQXYSeries_Clicked(this, const_cast<QPointF*>(&point)); };
 	void Signal_ColorChanged(QColor color) { callbackQXYSeries_ColorChanged(this, new QColor(color)); };
@@ -11054,7 +11054,7 @@ void QSplineSeries_DestroyQSplineSeries(void* ptr)
 class MyQStackedBarSeries: public QStackedBarSeries
 {
 public:
-	MyQStackedBarSeries(QObject *parent) : QStackedBarSeries(parent) {};
+	MyQStackedBarSeries(QObject *parent = Q_NULLPTR) : QStackedBarSeries(parent) {};
 	QAbstractSeries::SeriesType type() const { return static_cast<QAbstractSeries::SeriesType>(callbackQStackedBarSeries_Type(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_BarsetsAdded(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsAdded(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
 	void Signal_BarsetsRemoved(QList<QBarSet *> sets) { callbackQAbstractBarSeries_BarsetsRemoved(this, ({ QList<QBarSet *>* tmpValue = new QList<QBarSet *>(sets); QtCharts_PackedList { tmpValue, tmpValue->size() }; })); };
@@ -11133,7 +11133,7 @@ long long QStackedBarSeries_TypeDefault(void* ptr)
 class MyQVBarModelMapper: public QVBarModelMapper
 {
 public:
-	MyQVBarModelMapper(QObject *parent) : QVBarModelMapper(parent) {};
+	MyQVBarModelMapper(QObject *parent = Q_NULLPTR) : QVBarModelMapper(parent) {};
 	void Signal_FirstBarSetColumnChanged() { callbackQVBarModelMapper_FirstBarSetColumnChanged(this); };
 	void Signal_FirstRowChanged() { callbackQVBarModelMapper_FirstRowChanged(this); };
 	void Signal_LastBarSetColumnChanged() { callbackQVBarModelMapper_LastBarSetColumnChanged(this); };
@@ -11336,7 +11336,7 @@ int QVBarModelMapper_RowCount(void* ptr)
 class MyQVBoxPlotModelMapper: public QVBoxPlotModelMapper
 {
 public:
-	MyQVBoxPlotModelMapper(QObject *parent) : QVBoxPlotModelMapper(parent) {};
+	MyQVBoxPlotModelMapper(QObject *parent = Q_NULLPTR) : QVBoxPlotModelMapper(parent) {};
 	void Signal_FirstBoxSetColumnChanged() { callbackQVBoxPlotModelMapper_FirstBoxSetColumnChanged(this); };
 	void Signal_FirstRowChanged() { callbackQVBoxPlotModelMapper_FirstRowChanged(this); };
 	void Signal_LastBoxSetColumnChanged() { callbackQVBoxPlotModelMapper_LastBoxSetColumnChanged(this); };
@@ -11539,7 +11539,7 @@ int QVBoxPlotModelMapper_RowCount(void* ptr)
 class MyQVCandlestickModelMapper: public QVCandlestickModelMapper
 {
 public:
-	MyQVCandlestickModelMapper(QObject *parent) : QVCandlestickModelMapper(parent) {};
+	MyQVCandlestickModelMapper(QObject *parent = nullptr) : QVCandlestickModelMapper(parent) {};
 	void Signal_CloseRowChanged() { callbackQVCandlestickModelMapper_CloseRowChanged(this); };
 	void Signal_FirstSetColumnChanged() { callbackQVCandlestickModelMapper_FirstSetColumnChanged(this); };
 	void Signal_HighRowChanged() { callbackQVCandlestickModelMapper_HighRowChanged(this); };
@@ -11781,7 +11781,7 @@ int QVCandlestickModelMapper_TimestampRow(void* ptr)
 class MyQVPieModelMapper: public QVPieModelMapper
 {
 public:
-	MyQVPieModelMapper(QObject *parent) : QVPieModelMapper(parent) {};
+	MyQVPieModelMapper(QObject *parent = Q_NULLPTR) : QVPieModelMapper(parent) {};
 	void Signal_FirstRowChanged() { callbackQVPieModelMapper_FirstRowChanged(this); };
 	void Signal_LabelsColumnChanged() { callbackQVPieModelMapper_LabelsColumnChanged(this); };
 	void Signal_ModelReplaced() { callbackQVPieModelMapper_ModelReplaced(this); };
@@ -11984,7 +11984,7 @@ int QVPieModelMapper_ValuesColumn(void* ptr)
 class MyQVXYModelMapper: public QVXYModelMapper
 {
 public:
-	MyQVXYModelMapper(QObject *parent) : QVXYModelMapper(parent) {};
+	MyQVXYModelMapper(QObject *parent = Q_NULLPTR) : QVXYModelMapper(parent) {};
 	void Signal_FirstRowChanged() { callbackQVXYModelMapper_FirstRowChanged(this); };
 	void Signal_ModelReplaced() { callbackQVXYModelMapper_ModelReplaced(this); };
 	void Signal_RowCountChanged() { callbackQVXYModelMapper_RowCountChanged(this); };
@@ -12187,7 +12187,7 @@ int QVXYModelMapper_YColumn(void* ptr)
 class MyQValueAxis: public QValueAxis
 {
 public:
-	MyQValueAxis(QObject *parent) : QValueAxis(parent) {};
+	MyQValueAxis(QObject *parent = Q_NULLPTR) : QValueAxis(parent) {};
 	void applyNiceNumbers() { callbackQValueAxis_ApplyNiceNumbers(this); };
 	void Signal_LabelFormatChanged(const QString & format) { QByteArray t785987 = format.toUtf8(); QtCharts_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQValueAxis_LabelFormatChanged(this, formatPacked); };
 	void Signal_MaxChanged(qreal max) { callbackQValueAxis_MaxChanged(this, max); };

core/core.cpp

@@ -202,7 +202,7 @@
 class MyQAbstractAnimation: public QAbstractAnimation
 {
 public:
-	MyQAbstractAnimation(QObject *parent) : QAbstractAnimation(parent) {};
+	MyQAbstractAnimation(QObject *parent = Q_NULLPTR) : QAbstractAnimation(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
 	void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
@@ -757,7 +757,7 @@ void QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(void* ptr)
 class MyQAbstractItemModel: public QAbstractItemModel
 {
 public:
-	MyQAbstractItemModel(QObject *parent) : QAbstractItemModel(parent) {};
+	MyQAbstractItemModel(QObject *parent = Q_NULLPTR) : QAbstractItemModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
@@ -2266,7 +2266,7 @@ void* QAbstractItemModel_____itemData_keyList_newList(void* ptr)
 class MyQAbstractListModel: public QAbstractListModel
 {
 public:
-	MyQAbstractListModel(QObject *parent) : QAbstractListModel(parent) {};
+	MyQAbstractListModel(QObject *parent = Q_NULLPTR) : QAbstractListModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractListModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
 	QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
@@ -2480,7 +2480,7 @@ void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilterDefault(void* p
 class MyQAbstractProxyModel: public QAbstractProxyModel
 {
 public:
-	MyQAbstractProxyModel(QObject *parent) : QAbstractProxyModel(parent) {};
+	MyQAbstractProxyModel(QObject *parent = Q_NULLPTR) : QAbstractProxyModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
 	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
@@ -2787,7 +2787,7 @@ int QAbstractProxyModel_RowCountDefault(void* ptr, void* parent)
 class MyQAbstractState: public QAbstractState
 {
 public:
-	MyQAbstractState(QState *parent) : QAbstractState(parent) {};
+	MyQAbstractState(QState *parent = Q_NULLPTR) : QAbstractState(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
 	void Signal_Entered() { callbackQAbstractState_Entered(this); };
@@ -2879,7 +2879,7 @@ char QAbstractState_Active(void* ptr)
 class MyQAbstractTableModel: public QAbstractTableModel
 {
 public:
-	MyQAbstractTableModel(QObject *parent) : QAbstractTableModel(parent) {};
+	MyQAbstractTableModel(QObject *parent = Q_NULLPTR) : QAbstractTableModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractTableModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
 	QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
@@ -3045,7 +3045,7 @@ int QAbstractTableModel_RowCountDefault(void* ptr, void* parent)
 class MyQAbstractTransition: public QAbstractTransition
 {
 public:
-	MyQAbstractTransition(QState *sourceState) : QAbstractTransition(sourceState) {};
+	MyQAbstractTransition(QState *sourceState = Q_NULLPTR) : QAbstractTransition(sourceState) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventTest(QEvent * event) { return callbackQAbstractTransition_EventTest(this, event) != 0; };
 	void onTransition(QEvent * event) { callbackQAbstractTransition_OnTransition(this, event); };
@@ -3223,7 +3223,7 @@ void* QAbstractTransition___targetStates_newList(void* ptr)
 class MyQAnimationGroup: public QAnimationGroup
 {
 public:
-	MyQAnimationGroup(QObject *parent) : QAnimationGroup(parent) {};
+	MyQAnimationGroup(QObject *parent = Q_NULLPTR) : QAnimationGroup(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
 	void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
@@ -3522,8 +3522,8 @@ int QBitArray_Size(void* ptr)
 class MyQBuffer: public QBuffer
 {
 public:
-	MyQBuffer(QByteArray *byteArray, QObject *parent) : QBuffer(byteArray, parent) {};
+	MyQBuffer(QByteArray *byteArray, QObject *parent = Q_NULLPTR) : QBuffer(byteArray, parent) {};
-	MyQBuffer(QObject *parent) : QBuffer(parent) {};
+	MyQBuffer(QObject *parent = Q_NULLPTR) : QBuffer(parent) {};
 	bool open(QIODevice::OpenMode flags) { return callbackQIODevice_Open(this, flags) != 0; };
 	bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
 	qint64 readData(char * data, qint64 len) { QtCore_PackedString dataPacked = { data, len };return callbackQBuffer_ReadData(this, dataPacked, len); };
@@ -6880,7 +6880,7 @@ void QEvent_SetT(void* ptr, unsigned short vus)
 class MyQEventLoop: public QEventLoop
 {
 public:
-	MyQEventLoop(QObject *parent) : QEventLoop(parent) {};
+	MyQEventLoop(QObject *parent = Q_NULLPTR) : QEventLoop(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void quit() { callbackQEventLoop_Quit(this); };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
@@ -7004,8 +7004,8 @@ void QEventLoopLocker_DestroyQEventLoopLocker(void* ptr)
 class MyQEventTransition: public QEventTransition
 {
 public:
-	MyQEventTransition(QObject *object, QEvent::Type type, QState *sourceState) : QEventTransition(object, type, sourceState) {};
+	MyQEventTransition(QObject *object, QEvent::Type type, QState *sourceState = Q_NULLPTR) : QEventTransition(object, type, sourceState) {};
-	MyQEventTransition(QState *sourceState) : QEventTransition(sourceState) {};
+	MyQEventTransition(QState *sourceState = Q_NULLPTR) : QEventTransition(sourceState) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventTest(QEvent * event) { return callbackQEventTransition_EventTest(this, event) != 0; };
 	void onTransition(QEvent * event) { callbackQEventTransition_OnTransition(this, event); };
@@ -7801,7 +7801,7 @@ unsigned int QFileInfo_OwnerId(void* ptr)
 class MyQFileSelector: public QFileSelector
 {
 public:
-	MyQFileSelector(QObject *parent) : QFileSelector(parent) {};
+	MyQFileSelector(QObject *parent = Q_NULLPTR) : QFileSelector(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -7889,8 +7889,8 @@ void* QFileSelector_Select2(void* ptr, void* filePath)
 class MyQFileSystemWatcher: public QFileSystemWatcher
 {
 public:
-	MyQFileSystemWatcher(QObject *parent) : QFileSystemWatcher(parent) {};
+	MyQFileSystemWatcher(QObject *parent = Q_NULLPTR) : QFileSystemWatcher(parent) {};
-	MyQFileSystemWatcher(const QStringList &paths, QObject *parent) : QFileSystemWatcher(paths, parent) {};
+	MyQFileSystemWatcher(const QStringList &paths, QObject *parent = Q_NULLPTR) : QFileSystemWatcher(paths, parent) {};
 	void Signal_DirectoryChanged(const QString & path) { QByteArray t3150ec = path.toUtf8(); QtCore_PackedString pathPacked = { const_cast<char*>(t3150ec.prepend("WHITESPACE").constData()+10), t3150ec.size()-10 };callbackQFileSystemWatcher_DirectoryChanged(this, pathPacked); };
 	void Signal_FileChanged(const QString & path) { QByteArray t3150ec = path.toUtf8(); QtCore_PackedString pathPacked = { const_cast<char*>(t3150ec.prepend("WHITESPACE").constData()+10), t3150ec.size()-10 };callbackQFileSystemWatcher_FileChanged(this, pathPacked); };
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
@@ -8046,7 +8046,7 @@ struct QtCore_PackedString QFileSystemWatcher_Files(void* ptr)
 class MyQFinalState: public QFinalState
 {
 public:
-	MyQFinalState(QState *parent) : QFinalState(parent) {};
+	MyQFinalState(QState *parent = Q_NULLPTR) : QFinalState(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	void onEntry(QEvent * event) { callbackQFinalState_OnEntry(this, event); };
 	void onExit(QEvent * event) { callbackQFinalState_OnExit(this, event); };
@@ -8138,8 +8138,8 @@ void* QGenericReturnArgument_NewQGenericReturnArgument(char* name, void* data)
 class MyQHistoryState: public QHistoryState
 {
 public:
-	MyQHistoryState(HistoryType type, QState *parent) : QHistoryState(type, parent) {};
+	MyQHistoryState(HistoryType type, QState *parent = Q_NULLPTR) : QHistoryState(type, parent) {};
-	MyQHistoryState(QState *parent) : QHistoryState(parent) {};
+	MyQHistoryState(QState *parent = Q_NULLPTR) : QHistoryState(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	void Signal_DefaultStateChanged() { callbackQHistoryState_DefaultStateChanged(this); };
 	void Signal_DefaultTransitionChanged() { callbackQHistoryState_DefaultTransitionChanged(this); };
@@ -8924,7 +8924,7 @@ long long QIODevice_SizeDefault(void* ptr)
 class MyQIdentityProxyModel: public QIdentityProxyModel
 {
 public:
-	MyQIdentityProxyModel(QObject *parent) : QIdentityProxyModel(parent) {};
+	MyQIdentityProxyModel(QObject *parent = Q_NULLPTR) : QIdentityProxyModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
@@ -9156,7 +9156,7 @@ void* QItemSelection___indexes_newList(void* ptr)
 class MyQItemSelectionModel: public QItemSelectionModel
 {
 public:
-	MyQItemSelectionModel(QAbstractItemModel *model) : QItemSelectionModel(model) {};
+	MyQItemSelectionModel(QAbstractItemModel *model = Q_NULLPTR) : QItemSelectionModel(model) {};
 	MyQItemSelectionModel(QAbstractItemModel *model, QObject *parent) : QItemSelectionModel(model, parent) {};
 	void clear() { callbackQItemSelectionModel_Clear(this); };
 	void clearCurrentIndex() { callbackQItemSelectionModel_ClearCurrentIndex(this); };
@@ -10363,10 +10363,10 @@ int QLatin1String_Size(void* ptr)
 class MyQLibrary: public QLibrary
 {
 public:
-	MyQLibrary(QObject *parent) : QLibrary(parent) {};
+	MyQLibrary(QObject *parent = Q_NULLPTR) : QLibrary(parent) {};
-	MyQLibrary(const QString &fileName, QObject *parent) : QLibrary(fileName, parent) {};
+	MyQLibrary(const QString &fileName, QObject *parent = Q_NULLPTR) : QLibrary(fileName, parent) {};
-	MyQLibrary(const QString &fileName, const QString &version, QObject *parent) : QLibrary(fileName, version, parent) {};
+	MyQLibrary(const QString &fileName, const QString &version, QObject *parent = Q_NULLPTR) : QLibrary(fileName, version, parent) {};
-	MyQLibrary(const QString &fileName, int verNum, QObject *parent) : QLibrary(fileName, verNum, parent) {};
+	MyQLibrary(const QString &fileName, int verNum, QObject *parent = Q_NULLPTR) : QLibrary(fileName, verNum, parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -12840,7 +12840,7 @@ void* QMutexLocker_Mutex(void* ptr)
 class MyQObject: public QObject
 {
 public:
-	MyQObject(QObject *parent) : QObject(parent) {};
+	MyQObject(QObject *parent = Q_NULLPTR) : QObject(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -14149,7 +14149,7 @@ char QObjectCleanupHandler_IsEmpty(void* ptr)
 class MyQParallelAnimationGroup: public QParallelAnimationGroup
 {
 public:
-	MyQParallelAnimationGroup(QObject *parent) : QParallelAnimationGroup(parent) {};
+	MyQParallelAnimationGroup(QObject *parent = Q_NULLPTR) : QParallelAnimationGroup(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void updateCurrentTime(int currentTime) { callbackQParallelAnimationGroup_UpdateCurrentTime(this, currentTime); };
 	void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
@@ -14246,8 +14246,8 @@ int QParallelAnimationGroup_DurationDefault(void* ptr)
 class MyQPauseAnimation: public QPauseAnimation
 {
 public:
-	MyQPauseAnimation(QObject *parent) : QPauseAnimation(parent) {};
+	MyQPauseAnimation(QObject *parent = Q_NULLPTR) : QPauseAnimation(parent) {};
-	MyQPauseAnimation(int msecs, QObject *parent) : QPauseAnimation(msecs, parent) {};
+	MyQPauseAnimation(int msecs, QObject *parent = Q_NULLPTR) : QPauseAnimation(msecs, parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	void updateCurrentTime(int vin) { callbackQPauseAnimation_UpdateCurrentTime(this, vin); };
 	int duration() const { return callbackQPauseAnimation_Duration(const_cast<void*>(static_cast<const void*>(this))); };
@@ -14450,8 +14450,8 @@ int QPersistentModelIndex_Row(void* ptr)
 class MyQPluginLoader: public QPluginLoader
 {
 public:
-	MyQPluginLoader(QObject *parent) : QPluginLoader(parent) {};
+	MyQPluginLoader(QObject *parent = Q_NULLPTR) : QPluginLoader(parent) {};
-	MyQPluginLoader(const QString &fileName, QObject *parent) : QPluginLoader(fileName, parent) {};
+	MyQPluginLoader(const QString &fileName, QObject *parent = Q_NULLPTR) : QPluginLoader(fileName, parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -14755,8 +14755,8 @@ double QPointF_Y(void* ptr)
 class MyQPropertyAnimation: public QPropertyAnimation
 {
 public:
-	MyQPropertyAnimation(QObject *parent) : QPropertyAnimation(parent) {};
+	MyQPropertyAnimation(QObject *parent = Q_NULLPTR) : QPropertyAnimation(parent) {};
-	MyQPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent) : QPropertyAnimation(target, propertyName, parent) {};
+	MyQPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = Q_NULLPTR) : QPropertyAnimation(target, propertyName, parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void updateCurrentValue(const QVariant & value) { callbackQVariantAnimation_UpdateCurrentValue(this, const_cast<QVariant*>(&value)); };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
@@ -16105,7 +16105,7 @@ char QRunnable_AutoDelete(void* ptr)
 class MyQSaveFile: public QSaveFile
 {
 public:
-	MyQSaveFile(QObject *parent) : QSaveFile(parent) {};
+	MyQSaveFile(QObject *parent = Q_NULLPTR) : QSaveFile(parent) {};
 	MyQSaveFile(const QString &name) : QSaveFile(name) {};
 	MyQSaveFile(const QString &name, QObject *parent) : QSaveFile(name, parent) {};
 	bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
@@ -16302,7 +16302,7 @@ int QSemaphore_Available(void* ptr)
 class MyQSequentialAnimationGroup: public QSequentialAnimationGroup
 {
 public:
-	MyQSequentialAnimationGroup(QObject *parent) : QSequentialAnimationGroup(parent) {};
+	MyQSequentialAnimationGroup(QObject *parent = Q_NULLPTR) : QSequentialAnimationGroup(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void Signal_CurrentAnimationChanged(QAbstractAnimation * current) { callbackQSequentialAnimationGroup_CurrentAnimationChanged(this, current); };
 	void updateCurrentTime(int currentTime) { callbackQSequentialAnimationGroup_UpdateCurrentTime(this, currentTime); };
@@ -16445,11 +16445,11 @@ int QSequentialIterable_Size(void* ptr)
 class MyQSettings: public QSettings
 {
 public:
-	MyQSettings(Format format, Scope scope, const QString &organization, const QString &application, QObject *parent) : QSettings(format, scope, organization, application, parent) {};
+	MyQSettings(Format format, Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(format, scope, organization, application, parent) {};
-	MyQSettings(QObject *parent) : QSettings(parent) {};
+	MyQSettings(QObject *parent = Q_NULLPTR) : QSettings(parent) {};
-	MyQSettings(Scope scope, const QString &organization, const QString &application, QObject *parent) : QSettings(scope, organization, application, parent) {};
+	MyQSettings(Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(scope, organization, application, parent) {};
-	MyQSettings(const QString &fileName, Format format, QObject *parent) : QSettings(fileName, format, parent) {};
+	MyQSettings(const QString &fileName, Format format, QObject *parent = Q_NULLPTR) : QSettings(fileName, format, parent) {};
-	MyQSettings(const QString &organization, const QString &application, QObject *parent) : QSettings(organization, application, parent) {};
+	MyQSettings(const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(organization, application, parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -16841,8 +16841,8 @@ void* QSharedData_NewQSharedData2(void* other)
 class MyQSharedMemory: public QSharedMemory
 {
 public:
-	MyQSharedMemory(QObject *parent) : QSharedMemory(parent) {};
+	MyQSharedMemory(QObject *parent = Q_NULLPTR) : QSharedMemory(parent) {};
-	MyQSharedMemory(const QString &key, QObject *parent) : QSharedMemory(key, parent) {};
+	MyQSharedMemory(const QString &key, QObject *parent = Q_NULLPTR) : QSharedMemory(key, parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -17123,7 +17123,7 @@ void QSignalBlocker_DestroyQSignalBlocker(void* ptr)
 class MyQSignalMapper: public QSignalMapper
 {
 public:
-	MyQSignalMapper(QObject *parent) : QSignalMapper(parent) {};
+	MyQSignalMapper(QObject *parent = Q_NULLPTR) : QSignalMapper(parent) {};
 	void map() { callbackQSignalMapper_Map(this); };
 	void map(QObject * sender) { callbackQSignalMapper_Map2(this, sender); };
 	void Signal_Mapped4(QObject * object) { callbackQSignalMapper_Mapped4(this, object); };
@@ -17317,8 +17317,8 @@ void* QSignalMapper_Mapping(void* ptr, int id)
 class MyQSignalTransition: public QSignalTransition
 {
 public:
-	MyQSignalTransition(QState *sourceState) : QSignalTransition(sourceState) {};
+	MyQSignalTransition(QState *sourceState = Q_NULLPTR) : QSignalTransition(sourceState) {};
-	MyQSignalTransition(const QObject *sender, const char *signal, QState *sourceState) : QSignalTransition(sender, signal, sourceState) {};
+	MyQSignalTransition(const QObject *sender, const char *signal, QState *sourceState = Q_NULLPTR) : QSignalTransition(sender, signal, sourceState) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventTest(QEvent * event) { return callbackQSignalTransition_EventTest(this, event) != 0; };
 	void onTransition(QEvent * event) { callbackQSignalTransition_OnTransition(this, event); };
@@ -17706,7 +17706,7 @@ char QSocketNotifier_IsEnabled(void* ptr)
 class MyQSortFilterProxyModel: public QSortFilterProxyModel
 {
 public:
-	MyQSortFilterProxyModel(QObject *parent) : QSortFilterProxyModel(parent) {};
+	MyQSortFilterProxyModel(QObject *parent = Q_NULLPTR) : QSortFilterProxyModel(parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
@@ -18095,8 +18095,8 @@ void QStandardPaths_QStandardPaths_SetTestModeEnabled(char testMode)
 class MyQState: public QState
 {
 public:
-	MyQState(ChildMode childMode, QState *parent) : QState(childMode, parent) {};
+	MyQState(ChildMode childMode, QState *parent = Q_NULLPTR) : QState(childMode, parent) {};
-	MyQState(QState *parent) : QState(parent) {};
+	MyQState(QState *parent = Q_NULLPTR) : QState(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	void Signal_ChildModeChanged() { callbackQState_ChildModeChanged(this); };
 	void Signal_ErrorStateChanged() { callbackQState_ErrorStateChanged(this); };
@@ -18291,8 +18291,8 @@ void* QState___transitions_newList(void* ptr)
 class MyQStateMachine: public QStateMachine
 {
 public:
-	MyQStateMachine(QObject *parent) : QStateMachine(parent) {};
+	MyQStateMachine(QObject *parent = Q_NULLPTR) : QStateMachine(parent) {};
-	MyQStateMachine(QState::ChildMode childMode, QObject *parent) : QStateMachine(childMode, parent) {};
+	MyQStateMachine(QState::ChildMode childMode, QObject *parent = Q_NULLPTR) : QStateMachine(childMode, parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void onEntry(QEvent * event) { callbackQState_OnEntry(this, event); };
@@ -18717,8 +18717,8 @@ void* QStorageInfo___mountedVolumes_newList(void* ptr)
 class MyQStringListModel: public QStringListModel
 {
 public:
-	MyQStringListModel(QObject *parent) : QStringListModel(parent) {};
+	MyQStringListModel(QObject *parent = Q_NULLPTR) : QStringListModel(parent) {};
-	MyQStringListModel(const QStringList &strings, QObject *parent) : QStringListModel(strings, parent) {};
+	MyQStringListModel(const QStringList &strings, QObject *parent = Q_NULLPTR) : QStringListModel(strings, parent) {};
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
@@ -20392,10 +20392,10 @@ class MyQTextStream: public QTextStream
 {
 public:
 	MyQTextStream() : QTextStream() {};
-	MyQTextStream(QByteArray *array, QIODevice::OpenMode openMode) : QTextStream(array, openMode) {};
+	MyQTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(array, openMode) {};
 	MyQTextStream(QIODevice *device) : QTextStream(device) {};
-	MyQTextStream(QString *string, QIODevice::OpenMode openMode) : QTextStream(string, openMode) {};
+	MyQTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(string, openMode) {};
-	MyQTextStream(const QByteArray &array, QIODevice::OpenMode openMode) : QTextStream(array, openMode) {};
+	MyQTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly) : QTextStream(array, openMode) {};
 	 ~MyQTextStream() { callbackQTextStream_DestroyQTextStream(this); };
 };
 
@@ -20637,7 +20637,7 @@ long long QTextStream_Pos(void* ptr)
 class MyQThread: public QThread
 {
 public:
-	MyQThread(QObject *parent) : QThread(parent) {};
+	MyQThread(QObject *parent = Q_NULLPTR) : QThread(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void Signal_Finished() { callbackQThread_Finished(this); };
 	void quit() { callbackQThread_Quit(this); };
@@ -20871,7 +20871,7 @@ unsigned int QThread_StackSize(void* ptr)
 class MyQThreadPool: public QThreadPool
 {
 public:
-	MyQThreadPool(QObject *parent) : QThreadPool(parent) {};
+	MyQThreadPool(QObject *parent = Q_NULLPTR) : QThreadPool(parent) {};
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
@@ -21119,7 +21119,7 @@ int QTime_SecsTo(void* ptr, void* t)
 class MyQTimeLine: public QTimeLine
 {
 public:
-	MyQTimeLine(int duration, QObject *parent) : QTimeLine(duration, parent) {};
+	MyQTimeLine(int duration = 1000, QObject *parent = Q_NULLPTR) : QTimeLine(duration, parent) {};
 	void setCurrentTime(int msec) { callbackQTimeLine_SetCurrentTime(this, msec); };
 	void Signal_Finished() { callbackQTimeLine_Finished(this); };
 	void Signal_FrameChanged(int frame) { callbackQTimeLine_FrameChanged(this, frame); };
@@ -21654,7 +21654,7 @@ void* QTimeZone___windowsIdToIanaIds_newList2(void* ptr)
 class MyQTimer: public QTimer
 {
 public:
-	MyQTimer(QObject *parent) : QTimer(parent) {};
+	MyQTimer(QObject *parent = Q_NULLPTR) : QTimer(parent) {};
 	void start() { callbackQTimer_Start2(this); };
 	void start(int msec) { callbackQTimer_Start(this, msec); };
 	void stop() { callbackQTimer_Stop(this); };
@@ -21842,7 +21842,7 @@ void QTimerEvent_SetId(void* ptr, int vin)
 class MyQTranslator: public QTranslator
 {
 public:
-	MyQTranslator(QObject *parent) : QTranslator(parent) {};
+	MyQTranslator(QObject *parent = Q_NULLPTR) : QTranslator(parent) {};
 	QString translate(const char * context, const char * sourceText, const char * disambiguation, int n) const { QtCore_PackedString contextPacked = { const_cast<char*>(context), n };QtCore_PackedString sourceTextPacked = { const_cast<char*>(sourceText), n };QtCore_PackedString disambiguationPacked = { const_cast<char*>(disambiguation), n };return QString(callbackQTranslator_Translate(const_cast<void*>(static_cast<const void*>(this)), contextPacked, sourceTextPacked, disambiguationPacked, n)); };
 	bool isEmpty() const { return callbackQTranslator_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
 	bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
@@ -23162,7 +23162,7 @@ void* QVariant_____toMap_keyList_newList(void* ptr)
 class MyQVariantAnimation: public QVariantAnimation
 {
 public:
-	MyQVariantAnimation(QObject *parent) : QVariantAnimation(parent) {};
+	MyQVariantAnimation(QObject *parent = Q_NULLPTR) : QVariantAnimation(parent) {};
 	bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
 	void updateCurrentTime(int vin) { callbackQVariantAnimation_UpdateCurrentTime(this, vin); };
 	void updateCurrentValue(const QVariant & value) { callbackQVariantAnimation_UpdateCurrentValue(this, const_cast<QVariant*>(&value)); };

datavisualization/datavisualization.cpp

@@ -126,7 +126,7 @@ typedef QtDataVisualization::QValue3DAxisFormatter QValue3DAxisFormatter;
 class MyQ3DBars: public Q3DBars
 {
 public:
-	MyQ3DBars(const QSurfaceFormat *format, QWindow *parent) : Q3DBars(format, parent) {};
+	MyQ3DBars(const QSurfaceFormat *format = Q_NULLPTR, QWindow *parent = Q_NULLPTR) : Q3DBars(format, parent) {};
 	void Signal_BarSpacingChanged(const QSizeF & spacing) { callbackQ3DBars_BarSpacingChanged(this, const_cast<QSizeF*>(&spacing)); };
 	void Signal_BarSpacingRelativeChanged(bool relative) { callbackQ3DBars_BarSpacingRelativeChanged(this, relative); };
 	void Signal_BarThicknessChanged(float thicknessRatio) { callbackQ3DBars_BarThicknessChanged(this, thicknessRatio); };
@@ -472,7 +472,7 @@ void* Q3DBars___seriesList_newList(void* ptr)
 class MyQ3DCamera: public Q3DCamera
 {
 public:
-	MyQ3DCamera(QObject *parent) : Q3DCamera(parent) {};
+	MyQ3DCamera(QObject *parent = Q_NULLPTR) : Q3DCamera(parent) {};
 	void Signal_CameraPresetChanged(Q3DCamera::CameraPreset preset) { callbackQ3DCamera_CameraPresetChanged(this, preset); };
 	void copyValuesFrom(const Q3DObject & source) { callbackQ3DCamera_CopyValuesFrom(this, const_cast<Q3DObject*>(&source)); };
 	void Signal_MaxZoomLevelChanged(float zoomLevel) { callbackQ3DCamera_MaxZoomLevelChanged(this, zoomLevel); };
@@ -780,7 +780,7 @@ float Q3DCamera_ZoomLevel(void* ptr)
 class MyQ3DInputHandler: public Q3DInputHandler
 {
 public:
-	MyQ3DInputHandler(QObject *parent) : Q3DInputHandler(parent) {};
+	MyQ3DInputHandler(QObject *parent = Q_NULLPTR) : Q3DInputHandler(parent) {};
 	void mouseMoveEvent(QMouseEvent * event, const QPoint & mousePos) { callbackQ3DInputHandler_MouseMoveEvent(this, event, const_cast<QPoint*>(&mousePos)); };
 	void mousePressEvent(QMouseEvent * event, const QPoint & mousePos) { callbackQ3DInputHandler_MousePressEvent(this, event, const_cast<QPoint*>(&mousePos)); };
 	void mouseReleaseEvent(QMouseEvent * event, const QPoint & mousePos) { callbackQ3DInputHandler_MouseReleaseEvent(this, event, const_cast<QPoint*>(&mousePos)); };
@@ -986,7 +986,7 @@ char Q3DInputHandler_IsZoomEnabled(void* ptr)
 class MyQ3DLight: public Q3DLight
 {
 public:
-	MyQ3DLight(QObject *parent) : Q3DLight(parent) {};
+	MyQ3DLight(QObject *parent = Q_NULLPTR) : Q3DLight(parent) {};
 	 ~MyQ3DLight() { callbackQ3DLight_DestroyQ3DLight(this); };
 };
 
@@ -1044,7 +1044,7 @@ void Q3DLight_DestroyQ3DLightDefault(void* ptr)
 class MyQ3DObject: public Q3DObject
 {
 public:
-	MyQ3DObject(QObject *parent) : Q3DObject(parent) {};
+	MyQ3DObject(QObject *parent = Q_NULLPTR) : Q3DObject(parent) {};
 	void copyValuesFrom(const Q3DObject & source) { callbackQ3DObject_CopyValuesFrom(this, const_cast<Q3DObject*>(&source)); };
 	void Signal_PositionChanged(const QVector3D & position) { callbackQ3DObject_PositionChanged(this, const_cast<QVector3D*>(&position)); };
 	 ~MyQ3DObject() { callbackQ3DObject_DestroyQ3DObject(this); };
@@ -1154,7 +1154,7 @@ char Q3DObject_IsDirty(void* ptr)
 class MyQ3DScatter: public Q3DScatter
 {
 public:
-	MyQ3DScatter(const QSurfaceFormat *format, QWindow *parent) : Q3DScatter(format, parent) {};
+	MyQ3DScatter(const QSurfaceFormat *format = Q_NULLPTR, QWindow *parent = Q_NULLPTR) : Q3DScatter(format, parent) {};
 	void Signal_AxisXChanged(QValue3DAxis * axis) { callbackQ3DScatter_AxisXChanged(this, axis); };
 	void Signal_AxisYChanged(QValue3DAxis * axis) { callbackQ3DScatter_AxisYChanged(this, axis); };
 	void Signal_AxisZChanged(QValue3DAxis * axis) { callbackQ3DScatter_AxisZChanged(this, axis); };
@@ -1339,7 +1339,7 @@ void* Q3DScatter___axes_newList(void* ptr)
 class MyQ3DScene: public Q3DScene
 {
 public:
-	MyQ3DScene(QObject *parent) : Q3DScene(parent) {};
+	MyQ3DScene(QObject *parent = Q_NULLPTR) : Q3DScene(parent) {};
 	void Signal_ActiveCameraChanged(Q3DCamera * camera) { callbackQ3DScene_ActiveCameraChanged(this, camera); };
 	void Signal_ActiveLightChanged(Q3DLight * light) { callbackQ3DScene_ActiveLightChanged(this, light); };
 	void Signal_DevicePixelRatioChanged(float pixelRatio) { callbackQ3DScene_DevicePixelRatioChanged(this, pixelRatio); };
@@ -1667,7 +1667,7 @@ float Q3DScene_DevicePixelRatio(void* ptr)
 class MyQ3DSurface: public Q3DSurface
 {
 public:
-	MyQ3DSurface(const QSurfaceFormat *format, QWindow *parent) : Q3DSurface(format, parent) {};
+	MyQ3DSurface(const QSurfaceFormat *format = Q_NULLPTR, QWindow *parent = Q_NULLPTR) : Q3DSurface(format, parent) {};
 	void Signal_AxisXChanged(QValue3DAxis * axis) { callbackQ3DSurface_AxisXChanged(this, axis); };
 	void Signal_AxisYChanged(QValue3DAxis * axis) { callbackQ3DSurface_AxisYChanged(this, axis); };
 	void Signal_AxisZChanged(QValue3DAxis * axis) { callbackQ3DSurface_AxisZChanged(this, axis); };
@@ -1878,8 +1878,8 @@ void* Q3DSurface___axes_newList(void* ptr)
 class MyQ3DTheme: public Q3DTheme
 {
 public:
-	MyQ3DTheme(QObject *parent) : Q3DTheme(parent) {};
+	MyQ3DTheme(QObject *parent = Q_NULLPTR) : Q3DTheme(parent) {};
-	MyQ3DTheme(Theme themeType, QObject *parent) : Q3DTheme(themeType, parent) {};
+	MyQ3DTheme(Theme themeType, QObject *parent = Q_NULLPTR) : Q3DTheme(themeType, parent) {};
 	void Signal_AmbientLightStrengthChanged(float strength) { callbackQ3DTheme_AmbientLightStrengthChanged(this, strength); };
 	void Signal_BackgroundColorChanged(const QColor & color) { callbackQ3DTheme_BackgroundColorChanged(this, const_cast<QColor*>(&color)); };
 	void Signal_BackgroundEnabledChanged(bool enabled) { callbackQ3DTheme_BackgroundEnabledChanged(this, enabled); };
@@ -3536,7 +3536,7 @@ void* QAbstract3DGraph___customItems_newList(void* ptr)
 class MyQAbstract3DInputHandler: public QAbstract3DInputHandler
 {
 public:
-	MyQAbstract3DInputHandler(QObject *parent) : QAbstract3DInputHandler(parent) {};
+	MyQAbstract3DInputHandler(QObject *parent = Q_NULLPTR) : QAbstract3DInputHandler(parent) {};
 	void Signal_InputViewChanged(QAbstract3DInputHandler::InputView view) { callbackQAbstract3DInputHandler_InputViewChanged(this, view); };
 	void mouseDoubleClickEvent(QMouseEvent * event) { callbackQAbstract3DInputHandler_MouseDoubleClickEvent(this, event); };
 	void mouseMoveEvent(QMouseEvent * event, const QPoint & mousePos) { callbackQAbstract3DInputHandler_MouseMoveEvent(this, event, const_cast<QPoint*>(&mousePos)); };
@@ -4216,8 +4216,8 @@ void QAbstractDataProxy_DestroyQAbstractDataProxyDefault(void* ptr)
 class MyQBar3DSeries: public QBar3DSeries
 {
 public:
-	MyQBar3DSeries(QBarDataProxy *dataProxy, QObject *parent) : QBar3DSeries(dataProxy, parent) {};
+	MyQBar3DSeries(QBarDataProxy *dataProxy, QObject *parent = Q_NULLPTR) : QBar3DSeries(dataProxy, parent) {};
-	MyQBar3DSeries(QObject *parent) : QBar3DSeries(parent) {};
+	MyQBar3DSeries(QObject *parent = Q_NULLPTR) : QBar3DSeries(parent) {};
 	void Signal_DataProxyChanged(QBarDataProxy * proxy) { callbackQBar3DSeries_DataProxyChanged(this, proxy); };
 	void Signal_MeshAngleChanged(float angle) { callbackQBar3DSeries_MeshAngleChanged(this, angle); };
 	void Signal_SelectedBarChanged(const QPoint & position) { callbackQBar3DSeries_SelectedBarChanged(this, const_cast<QPoint*>(&position)); };
@@ -4444,7 +4444,7 @@ float QBarDataItem_Value(void* ptr)
 class MyQBarDataProxy: public QBarDataProxy
 {
 public:
-	MyQBarDataProxy(QObject *parent) : QBarDataProxy(parent) {};
+	MyQBarDataProxy(QObject *parent = Q_NULLPTR) : QBarDataProxy(parent) {};
 	void Signal_ArrayReset() { callbackQBarDataProxy_ArrayReset(this); };
 	void Signal_ColumnLabelsChanged() { callbackQBarDataProxy_ColumnLabelsChanged(this); };
 	void Signal_ItemChanged(int rowIndex, int columnIndex) { callbackQBarDataProxy_ItemChanged(this, rowIndex, columnIndex); };
@@ -4722,7 +4722,7 @@ int QBarDataProxy_RowCount(void* ptr)
 class MyQCategory3DAxis: public QCategory3DAxis
 {
 public:
-	MyQCategory3DAxis(QObject *parent) : QCategory3DAxis(parent) {};
+	MyQCategory3DAxis(QObject *parent = Q_NULLPTR) : QCategory3DAxis(parent) {};
 	void Signal_LabelsChanged() { callbackQCategory3DAxis_LabelsChanged(this); };
 	 ~MyQCategory3DAxis() { callbackQCategory3DAxis_DestroyQCategory3DAxis(this); };
 };
@@ -4806,8 +4806,8 @@ struct QtDataVisualization_PackedString QCategory3DAxis_Labels(void* ptr)
 class MyQCustom3DItem: public QCustom3DItem
 {
 public:
-	MyQCustom3DItem(QObject *parent) : QCustom3DItem(parent) {};
+	MyQCustom3DItem(QObject *parent = Q_NULLPTR) : QCustom3DItem(parent) {};
-	MyQCustom3DItem(const QString &meshFile, const QVector3D &position, const QVector3D &scaling, const QQuaternion &rotation, const QImage &texture, QObject *parent) : QCustom3DItem(meshFile, position, scaling, rotation, texture, parent) {};
+	MyQCustom3DItem(const QString &meshFile, const QVector3D &position, const QVector3D &scaling, const QQuaternion &rotation, const QImage &texture, QObject *parent = Q_NULLPTR) : QCustom3DItem(meshFile, position, scaling, rotation, texture, parent) {};
 	void Signal_MeshFileChanged(const QString & meshFile) { QByteArray tdc0aec = meshFile.toUtf8(); QtDataVisualization_PackedString meshFilePacked = { const_cast<char*>(tdc0aec.prepend("WHITESPACE").constData()+10), tdc0aec.size()-10 };callbackQCustom3DItem_MeshFileChanged(this, meshFilePacked); };
 	void Signal_PositionAbsoluteChanged(bool positionAbsolute) { callbackQCustom3DItem_PositionAbsoluteChanged(this, positionAbsolute); };
 	void Signal_PositionChanged(const QVector3D & position) { callbackQCustom3DItem_PositionChanged(this, const_cast<QVector3D*>(&position)); };
@@ -5150,8 +5150,8 @@ char QCustom3DItem_IsVisible(void* ptr)
 class MyQCustom3DLabel: public QCustom3DLabel
 {
 public:
-	MyQCustom3DLabel(QObject *parent) : QCustom3DLabel(parent) {};
+	MyQCustom3DLabel(QObject *parent = Q_NULLPTR) : QCustom3DLabel(parent) {};
-	MyQCustom3DLabel(const QString &text, const QFont &font, const QVector3D &position, const QVector3D &scaling, const QQuaternion &rotation, QObject *parent) : QCustom3DLabel(text, font, position, scaling, rotation, parent) {};
+	MyQCustom3DLabel(const QString &text, const QFont &font, const QVector3D &position, const QVector3D &scaling, const QQuaternion &rotation, QObject *parent = Q_NULLPTR) : QCustom3DLabel(text, font, position, scaling, rotation, parent) {};
 	void Signal_BackgroundColorChanged(const QColor & color) { callbackQCustom3DLabel_BackgroundColorChanged(this, const_cast<QColor*>(&color)); };
 	void Signal_BackgroundEnabledChanged(bool enabled) { callbackQCustom3DLabel_BackgroundEnabledChanged(this, enabled); };
 	void Signal_BorderEnabledChanged(bool enabled) { callbackQCustom3DLabel_BorderEnabledChanged(this, enabled); };
@@ -5432,7 +5432,7 @@ char QCustom3DLabel_IsFacingCamera(void* ptr)
 class MyQCustom3DVolume: public QCustom3DVolume
 {
 public:
-	MyQCustom3DVolume(QObject *parent) : QCustom3DVolume(parent) {};
+	MyQCustom3DVolume(QObject *parent = Q_NULLPTR) : QCustom3DVolume(parent) {};
 	void Signal_AlphaMultiplierChanged(float mult) { callbackQCustom3DVolume_AlphaMultiplierChanged(this, mult); };
 	void Signal_ColorTableChanged() { callbackQCustom3DVolume_ColorTableChanged(this); };
 	void Signal_DrawSliceFramesChanged(bool enabled) { callbackQCustom3DVolume_DrawSliceFramesChanged(this, enabled); };
@@ -5962,9 +5962,9 @@ void* QCustom3DVolume___colorTable_newList(void* ptr)
 class MyQHeightMapSurfaceDataProxy: public QHeightMapSurfaceDataProxy
 {
 public:
-	MyQHeightMapSurfaceDataProxy(QObject *parent) : QHeightMapSurfaceDataProxy(parent) {};
+	MyQHeightMapSurfaceDataProxy(QObject *parent = Q_NULLPTR) : QHeightMapSurfaceDataProxy(parent) {};
-	MyQHeightMapSurfaceDataProxy(const QImage &image, QObject *parent) : QHeightMapSurfaceDataProxy(image, parent) {};
+	MyQHeightMapSurfaceDataProxy(const QImage &image, QObject *parent = Q_NULLPTR) : QHeightMapSurfaceDataProxy(image, parent) {};
-	MyQHeightMapSurfaceDataProxy(const QString &filename, QObject *parent) : QHeightMapSurfaceDataProxy(filename, parent) {};
+	MyQHeightMapSurfaceDataProxy(const QString &filename, QObject *parent = Q_NULLPTR) : QHeightMapSurfaceDataProxy(filename, parent) {};
 	void Signal_HeightMapChanged(const QImage & image) { callbackQHeightMapSurfaceDataProxy_HeightMapChanged(this, const_cast<QImage*>(&image)); };
 	void Signal_HeightMapFileChanged(const QString & filename) { QByteArray t08deae = filename.toUtf8(); QtDataVisualization_PackedString filenamePacked = { const_cast<char*>(t08deae.prepend("WHITESPACE").constData()+10), t08deae.size()-10 };callbackQHeightMapSurfaceDataProxy_HeightMapFileChanged(this, filenamePacked); };
 	void Signal_MaxXValueChanged(float value) { callbackQHeightMapSurfaceDataProxy_MaxXValueChanged(this, value); };
@@ -6265,13 +6265,13 @@ float QHeightMapSurfaceDataProxy_MinZValue(void* ptr)
 class MyQItemModelBarDataProxy: public QItemModelBarDataProxy
 {
 public:
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, QObject *parent) : QItemModelBarDataProxy(itemModel, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, parent) {};
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, QObject *parent) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, parent) {};
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QString &rotationRole, QObject *parent) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rotationRole, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QString &rotationRole, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rotationRole, parent) {};
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QString &rotationRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rotationRole, rowCategories, columnCategories, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QString &rotationRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rotationRole, rowCategories, columnCategories, parent) {};
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rowCategories, columnCategories, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &valueRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, rowRole, columnRole, valueRole, rowCategories, columnCategories, parent) {};
-	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &valueRole, QObject *parent) : QItemModelBarDataProxy(itemModel, valueRole, parent) {};
+	MyQItemModelBarDataProxy(QAbstractItemModel *itemModel, const QString &valueRole, QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(itemModel, valueRole, parent) {};
-	MyQItemModelBarDataProxy(QObject *parent) : QItemModelBarDataProxy(parent) {};
+	MyQItemModelBarDataProxy(QObject *parent = Q_NULLPTR) : QItemModelBarDataProxy(parent) {};
 	void Signal_AutoColumnCategoriesChanged(bool enable) { callbackQItemModelBarDataProxy_AutoColumnCategoriesChanged(this, enable); };
 	void Signal_AutoRowCategoriesChanged(bool enable) { callbackQItemModelBarDataProxy_AutoRowCategoriesChanged(this, enable); };
 	void Signal_ColumnCategoriesChanged() { callbackQItemModelBarDataProxy_ColumnCategoriesChanged(this); };
@@ -7084,10 +7084,10 @@ char QItemModelBarDataProxy_UseModelCategories(void* ptr)
 class MyQItemModelScatterDataProxy: public QItemModelScatterDataProxy
 {
 public:
-	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, QObject *parent) : QItemModelScatterDataProxy(itemModel, parent) {};
+	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, QObject *parent = Q_NULLPTR) : QItemModelScatterDataProxy(itemModel, parent) {};
-	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, QObject *parent) : QItemModelScatterDataProxy(itemModel, xPosRole, yPosRole, zPosRole, parent) {};
+	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, QObject *parent = Q_NULLPTR) : QItemModelScatterDataProxy(itemModel, xPosRole, yPosRole, zPosRole, parent) {};
-	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, const QString &rotationRole, QObject *parent) : QItemModelScatterDataProxy(itemModel, xPosRole, yPosRole, zPosRole, rotationRole, parent) {};
+	MyQItemModelScatterDataProxy(QAbstractItemModel *itemModel, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, const QString &rotationRole, QObject *parent = Q_NULLPTR) : QItemModelScatterDataProxy(itemModel, xPosRole, yPosRole, zPosRole, rotationRole, parent) {};
-	MyQItemModelScatterDataProxy(QObject *parent) : QItemModelScatterDataProxy(parent) {};
+	MyQItemModelScatterDataProxy(QObject *parent = Q_NULLPTR) : QItemModelScatterDataProxy(parent) {};
 	void Signal_ItemModelChanged(const QAbstractItemModel * itemModel) { callbackQItemModelScatterDataProxy_ItemModelChanged(this, const_cast<QAbstractItemModel*>(itemModel)); };
 	void Signal_RotationRoleChanged(const QString & role) { QByteArray t8dca46 = role.toUtf8(); QtDataVisualization_PackedString rolePacked = { const_cast<char*>(t8dca46.prepend("WHITESPACE").constData()+10), t8dca46.size()-10 };callbackQItemModelScatterDataProxy_RotationRoleChanged(this, rolePacked); };
 	void Signal_RotationRolePatternChanged(const QRegExp & pattern) { callbackQItemModelScatterDataProxy_RotationRolePatternChanged(this, const_cast<QRegExp*>(&pattern)); };
@@ -7611,13 +7611,13 @@ struct QtDataVisualization_PackedString QItemModelScatterDataProxy_ZPosRoleRepla
 class MyQItemModelSurfaceDataProxy: public QItemModelSurfaceDataProxy
 {
 public:
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, parent) {};
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, xPosRole, yPosRole, zPosRole, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, xPosRole, yPosRole, zPosRole, parent) {};
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, xPosRole, yPosRole, zPosRole, rowCategories, columnCategories, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &xPosRole, const QString &yPosRole, const QString &zPosRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, xPosRole, yPosRole, zPosRole, rowCategories, columnCategories, parent) {};
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &yPosRole, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, yPosRole, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &yPosRole, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, yPosRole, parent) {};
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &yPosRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, yPosRole, rowCategories, columnCategories, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &rowRole, const QString &columnRole, const QString &yPosRole, const QStringList &rowCategories, const QStringList &columnCategories, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, rowRole, columnRole, yPosRole, rowCategories, columnCategories, parent) {};
-	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &yPosRole, QObject *parent) : QItemModelSurfaceDataProxy(itemModel, yPosRole, parent) {};
+	MyQItemModelSurfaceDataProxy(QAbstractItemModel *itemModel, const QString &yPosRole, QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(itemModel, yPosRole, parent) {};
-	MyQItemModelSurfaceDataProxy(QObject *parent) : QItemModelSurfaceDataProxy(parent) {};
+	MyQItemModelSurfaceDataProxy(QObject *parent = Q_NULLPTR) : QItemModelSurfaceDataProxy(parent) {};
 	void Signal_AutoColumnCategoriesChanged(bool enable) { callbackQItemModelSurfaceDataProxy_AutoColumnCategoriesChanged(this, enable); };
 	void Signal_AutoRowCategoriesChanged(bool enable) { callbackQItemModelSurfaceDataProxy_AutoRowCategoriesChanged(this, enable); };
 	void Signal_ColumnCategoriesChanged() { callbackQItemModelSurfaceDataProxy_ColumnCategoriesChanged(this); };
@@ -8508,7 +8508,7 @@ char QItemModelSurfaceDataProxy_UseModelCategories(void* ptr)
 class MyQLogValue3DAxisFormatter: public QLogValue3DAxisFormatter
 {
 public:
-	MyQLogValue3DAxisFormatter(QObject *parent) : QLogValue3DAxisFormatter(parent) {};
+	MyQLogValue3DAxisFormatter(QObject *parent = Q_NULLPTR) : QLogValue3DAxisFormatter(parent) {};
 	void Signal_AutoSubGridChanged(bool enabled) { callbackQLogValue3DAxisFormatter_AutoSubGridChanged(this, enabled); };
 	void Signal_BaseChanged(qreal base) { callbackQLogValue3DAxisFormatter_BaseChanged(this, base); };
 	void Signal_ShowEdgeLabelsChanged(bool enabled) { callbackQLogValue3DAxisFormatter_ShowEdgeLabelsChanged(this, enabled); };
@@ -8644,8 +8644,8 @@ double QLogValue3DAxisFormatter_Base(void* ptr)
 class MyQScatter3DSeries: public QScatter3DSeries
 {
 public:
-	MyQScatter3DSeries(QObject *parent) : QScatter3DSeries(parent) {};
+	MyQScatter3DSeries(QObject *parent = Q_NULLPTR) : QScatter3DSeries(parent) {};
-	MyQScatter3DSeries(QScatterDataProxy *dataProxy, QObject *parent) : QScatter3DSeries(dataProxy, parent) {};
+	MyQScatter3DSeries(QScatterDataProxy *dataProxy, QObject *parent = Q_NULLPTR) : QScatter3DSeries(dataProxy, parent) {};
 	void Signal_DataProxyChanged(QScatterDataProxy * proxy) { callbackQScatter3DSeries_DataProxyChanged(this, proxy); };
 	void Signal_ItemSizeChanged(float size) { callbackQScatter3DSeries_ItemSizeChanged(this, size); };
 	void Signal_SelectedItemChanged(int index) { callbackQScatter3DSeries_SelectedItemChanged(this, index); };
@@ -8902,7 +8902,7 @@ float QScatterDataItem_Z(void* ptr)
 class MyQScatterDataProxy: public QScatterDataProxy
 {
 public:
-	MyQScatterDataProxy(QObject *parent) : QScatterDataProxy(parent) {};
+	MyQScatterDataProxy(QObject *parent = Q_NULLPTR) : QScatterDataProxy(parent) {};
 	void Signal_ArrayReset() { callbackQScatterDataProxy_ArrayReset(this); };
 	void Signal_ItemCountChanged(int count) { callbackQScatterDataProxy_ItemCountChanged(this, count); };
 	void Signal_ItemsAdded(int startIndex, int count) { callbackQScatterDataProxy_ItemsAdded(this, startIndex, count); };
@@ -9107,8 +9107,8 @@ int QScatterDataProxy_ItemCount(void* ptr)
 class MyQSurface3DSeries: public QSurface3DSeries
 {
 public:
-	MyQSurface3DSeries(QObject *parent) : QSurface3DSeries(parent) {};
+	MyQSurface3DSeries(QObject *parent = Q_NULLPTR) : QSurface3DSeries(parent) {};
-	MyQSurface3DSeries(QSurfaceDataProxy *dataProxy, QObject *parent) : QSurface3DSeries(dataProxy, parent) {};
+	MyQSurface3DSeries(QSurfaceDataProxy *dataProxy, QObject *parent = Q_NULLPTR) : QSurface3DSeries(dataProxy, parent) {};
 	void Signal_SelectedPointChanged(const QPoint & position) { callbackQSurface3DSeries_SelectedPointChanged(this, const_cast<QPoint*>(&position)); };
 	void Signal_DataProxyChanged(QSurfaceDataProxy * proxy) { callbackQSurface3DSeries_DataProxyChanged(this, proxy); };
 	void Signal_DrawModeChanged(QSurface3DSeries::DrawFlags mode) { callbackQSurface3DSeries_DrawModeChanged(this, mode); };
@@ -9449,7 +9449,7 @@ float QSurfaceDataItem_Z(void* ptr)
 class MyQSurfaceDataProxy: public QSurfaceDataProxy
 {
 public:
-	MyQSurfaceDataProxy(QObject *parent) : QSurfaceDataProxy(parent) {};
+	MyQSurfaceDataProxy(QObject *parent = Q_NULLPTR) : QSurfaceDataProxy(parent) {};
 	void Signal_ArrayReset() { callbackQSurfaceDataProxy_ArrayReset(this); };
 	void Signal_ColumnCountChanged(int count) { callbackQSurfaceDataProxy_ColumnCountChanged(this, count); };
 	void Signal_ItemChanged(int rowIndex, int columnIndex) { callbackQSurfaceDataProxy_ItemChanged(this, rowIndex, columnIndex); };
@@ -9691,7 +9691,7 @@ int QSurfaceDataProxy_RowCount(void* ptr)
 class MyQTouch3DInputHandler: public QTouch3DInputHandler
 {
 public:
-	MyQTouch3DInputHandler(QObject *parent) : QTouch3DInputHandler(parent) {};
+	MyQTouch3DInputHandler(QObject *parent = Q_NULLPTR) : QTouch3DInputHandler(parent) {};
 	void touchEvent(QTouchEvent * event) { callbackQTouch3DInputHandler_TouchEvent(this, event); };
 	 ~MyQTouch3DInputHandler() { callbackQTouch3DInputHandler_DestroyQTouch3DInputHandler(this); };
 };
@@ -9760,7 +9760,7 @@ void QTouch3DInputHandler_DestroyQTouch3DInputHandlerDefault(void* ptr)
 class MyQValue3DAxis: public QValue3DAxis
 {
 public:
-	MyQValue3DAxis(QObject *parent) : QValue3DAxis(parent) {};
+	MyQValue3DAxis(QObject *parent = Q_NULLPTR) : QValue3DAxis(parent) {};
 	void Signal_FormatterChanged(QValue3DAxisFormatter * formatter) { callbackQValue3DAxis_FormatterChanged(this, formatter); };
 	void Signal_LabelFormatChanged(const QString & format) { QByteArray t785987 = format.toUtf8(); QtDataVisualization_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQValue3DAxis_LabelFormatChanged(this, formatPacked); };
 	void Signal_ReversedChanged(bool enable) { callbackQValue3DAxis_ReversedChanged(this, enable); };
@@ -9948,7 +9948,7 @@ int QValue3DAxis_SubSegmentCount(void* ptr)
 class MyQValue3DAxisFormatter: public QValue3DAxisFormatter
 {
 public:
-	MyQValue3DAxisFormatter(QObject *parent) : QValue3DAxisFormatter(parent) {};
+	MyQValue3DAxisFormatter(QObject *parent = Q_NULLPTR) : QValue3DAxisFormatter(parent) {};
 	void recalculate() { callbackQValue3DAxisFormatter_Recalculate(this); };
 	 ~MyQValue3DAxisFormatter() { callbackQValue3DAxisFormatter_DestroyQValue3DAxisFormatter(this); };
 	QString stringForValue(qreal value, const QString & format) const { QByteArray t785987 = format.toUtf8(); QtDataVisualization_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };return QString(callbackQValue3DAxisFormatter_StringForValue(const_cast<void*>(static_cast<const void*>(this)), value, formatPacked)); };

dbus/dbus.cpp

@@ -1135,7 +1135,7 @@ char QDBusError_IsValid(void* ptr)
 class MyQDBusInterface: public QDBusInterface
 {
 public:
-	MyQDBusInterface(const QString &service, const QString &path, const QString &interface, const QDBusConnection &connection, QObject *parent) : QDBusInterface(service, path, interface, connection, parent) {};
+	MyQDBusInterface(const QString &service, const QString &path, const QString &interface = QString(), const QDBusConnection &connection = QDBusConnection::sessionBus(), QObject *parent = Q_NULLPTR) : QDBusInterface(service, path, interface, connection, parent) {};
 	bool event(QEvent * e) { return callbackQDBusAbstractInterface_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDBusAbstractInterface_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQDBusAbstractInterface_ChildEvent(this, event); };
@@ -1470,7 +1470,7 @@ void QDBusPendingCall_DestroyQDBusPendingCall(void* ptr)
 class MyQDBusPendingCallWatcher: public QDBusPendingCallWatcher
 {
 public:
-	MyQDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent) : QDBusPendingCallWatcher(call, parent) {};
+	MyQDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent = Q_NULLPTR) : QDBusPendingCallWatcher(call, parent) {};
 	void Signal_Finished(QDBusPendingCallWatcher * self) { callbackQDBusPendingCallWatcher_Finished(this, self); };
 	bool event(QEvent * e) { return callbackQDBusPendingCallWatcher_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDBusPendingCallWatcher_EventFilter(this, watched, event) != 0; };
@@ -1717,8 +1717,8 @@ int QDBusPendingReplyTypes_QDBusPendingReplyTypes_MetaTypeFor2(void* vqv)
 class MyQDBusServer: public QDBusServer
 {
 public:
-	MyQDBusServer(QObject *parent) : QDBusServer(parent) {};
+	MyQDBusServer(QObject *parent = Q_NULLPTR) : QDBusServer(parent) {};
-	MyQDBusServer(const QString &address, QObject *parent) : QDBusServer(address, parent) {};
+	MyQDBusServer(const QString &address, QObject *parent = Q_NULLPTR) : QDBusServer(address, parent) {};
 	void Signal_NewConnection(const QDBusConnection & connection) { callbackQDBusServer_NewConnection(this, const_cast<QDBusConnection*>(&connection)); };
 	 ~MyQDBusServer() { callbackQDBusServer_DestroyQDBusServer(this); };
 	bool event(QEvent * e) { return callbackQDBusServer_Event(this, e) != 0; };
@@ -2009,8 +2009,8 @@ void* QDBusServer_MetaObjectDefault(void* ptr)
 class MyQDBusServiceWatcher: public QDBusServiceWatcher
 {
 public:
-	MyQDBusServiceWatcher(QObject *parent) : QDBusServiceWatcher(parent) {};
+	MyQDBusServiceWatcher(QObject *parent = Q_NULLPTR) : QDBusServiceWatcher(parent) {};
-	MyQDBusServiceWatcher(const QString &service, const QDBusConnection &connection, WatchMode watchMode, QObject *parent) : QDBusServiceWatcher(service, connection, watchMode, parent) {};
+	MyQDBusServiceWatcher(const QString &service, const QDBusConnection &connection, WatchMode watchMode = WatchForOwnerChange, QObject *parent = Q_NULLPTR) : QDBusServiceWatcher(service, connection, watchMode, parent) {};
 	void Signal_ServiceRegistered(const QString & serviceName) { QByteArray tc151ab = serviceName.toUtf8(); QtDBus_PackedString serviceNamePacked = { const_cast<char*>(tc151ab.prepend("WHITESPACE").constData()+10), tc151ab.size()-10 };callbackQDBusServiceWatcher_ServiceRegistered(this, serviceNamePacked); };
 	void Signal_ServiceOwnerChanged(const QString & serviceName, const QString & oldOwner, const QString & newOwner) { QByteArray tc151ab = serviceName.toUtf8(); QtDBus_PackedString serviceNamePacked = { const_cast<char*>(tc151ab.prepend("WHITESPACE").constData()+10), tc151ab.size()-10 };QByteArray t9456b1 = oldOwner.toUtf8(); QtDBus_PackedString oldOwnerPacked = { const_cast<char*>(t9456b1.prepend("WHITESPACE").constData()+10), t9456b1.size()-10 };QByteArray t157d45 = newOwner.toUtf8(); QtDBus_PackedString newOwnerPacked = { const_cast<char*>(t157d45.prepend("WHITESPACE").constData()+10), t157d45.size()-10 };callbackQDBusServiceWatcher_ServiceOwnerChanged(this, serviceNamePacked, oldOwnerPacked, newOwnerPacked); };
 	void Signal_ServiceUnregistered(const QString & serviceName) { QByteArray tc151ab = serviceName.toUtf8(); QtDBus_PackedString serviceNamePacked = { const_cast<char*>(tc151ab.prepend("WHITESPACE").constData()+10), tc151ab.size()-10 };callbackQDBusServiceWatcher_ServiceUnregistered(this, serviceNamePacked); };
@@ -2457,7 +2457,7 @@ void* QDBusVariant_Variant(void* ptr)
 class MyQDBusVirtualObject: public QDBusVirtualObject
 {
 public:
-	MyQDBusVirtualObject(QObject *parent) : QDBusVirtualObject(parent) {};
+	MyQDBusVirtualObject(QObject *parent = Q_NULLPTR) : QDBusVirtualObject(parent) {};
 	bool handleMessage(const QDBusMessage & message, const QDBusConnection & connection) { return callbackQDBusVirtualObject_HandleMessage(this, const_cast<QDBusMessage*>(&message), const_cast<QDBusConnection*>(&connection)) != 0; };
 	 ~MyQDBusVirtualObject() { callbackQDBusVirtualObject_DestroyQDBusVirtualObject(this); };
 	QString introspect(const QString & path) const { QByteArray t3150ec = path.toUtf8(); QtDBus_PackedString pathPacked = { const_cast<char*>(t3150ec.prepend("WHITESPACE").constData()+10), t3150ec.size()-10 };return QString(callbackQDBusVirtualObject_Introspect(const_cast<void*>(static_cast<const void*>(this)), pathPacked)); };

designer/designer.cpp

@@ -247,7 +247,7 @@ void* QAbstractFormBuilder___applyProperties_properties_newList(void* ptr)
 class MyQDesignerActionEditorInterface: public QDesignerActionEditorInterface
 {
 public:
-	MyQDesignerActionEditorInterface(QWidget *parent, Qt::WindowFlags flags) : QDesignerActionEditorInterface(parent, flags) {};
+	MyQDesignerActionEditorInterface(QWidget *parent, Qt::WindowFlags flags = Qt::WindowFlags()) : QDesignerActionEditorInterface(parent, flags) {};
 	void manageAction(QAction * action) { callbackQDesignerActionEditorInterface_ManageAction(this, action); };
 	void setFormWindow(QDesignerFormWindowInterface * formWindow) { callbackQDesignerActionEditorInterface_SetFormWindow(this, formWindow); };
 	void unmanageAction(QAction * action) { callbackQDesignerActionEditorInterface_UnmanageAction(this, action); };
@@ -1108,7 +1108,7 @@ char QDesignerDynamicPropertySheetExtension_IsDynamicProperty(void* ptr, int ind
 class MyQDesignerFormEditorInterface: public QDesignerFormEditorInterface
 {
 public:
-	MyQDesignerFormEditorInterface(QObject *parent) : QDesignerFormEditorInterface(parent) {};
+	MyQDesignerFormEditorInterface(QObject *parent = Q_NULLPTR) : QDesignerFormEditorInterface(parent) {};
 	 ~MyQDesignerFormEditorInterface() { callbackQDesignerFormEditorInterface_DestroyQDesignerFormEditorInterface(this); };
 	bool event(QEvent * e) { return callbackQDesignerFormEditorInterface_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerFormEditorInterface_EventFilter(this, watched, event) != 0; };
@@ -3053,7 +3053,7 @@ void* QDesignerMemberSheetExtension___parameterTypes_newList(void* ptr)
 class MyQDesignerObjectInspectorInterface: public QDesignerObjectInspectorInterface
 {
 public:
-	MyQDesignerObjectInspectorInterface(QWidget *parent, Qt::WindowFlags flags) : QDesignerObjectInspectorInterface(parent, flags) {};
+	MyQDesignerObjectInspectorInterface(QWidget *parent, Qt::WindowFlags flags = Qt::WindowFlags()) : QDesignerObjectInspectorInterface(parent, flags) {};
 	void setFormWindow(QDesignerFormWindowInterface * formWindow) { callbackQDesignerObjectInspectorInterface_SetFormWindow(this, formWindow); };
 	 ~MyQDesignerObjectInspectorInterface() { callbackQDesignerObjectInspectorInterface_DestroyQDesignerObjectInspectorInterface(this); };
 	QDesignerFormEditorInterface * core() const { return static_cast<QDesignerFormEditorInterface*>(callbackQDesignerObjectInspectorInterface_Core(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -3631,7 +3631,7 @@ void* QDesignerObjectInspectorInterface_MetaObjectDefault(void* ptr)
 class MyQDesignerPropertyEditorInterface: public QDesignerPropertyEditorInterface
 {
 public:
-	MyQDesignerPropertyEditorInterface(QWidget *parent, Qt::WindowFlags flags) : QDesignerPropertyEditorInterface(parent, flags) {};
+	MyQDesignerPropertyEditorInterface(QWidget *parent, Qt::WindowFlags flags = Qt::WindowFlags()) : QDesignerPropertyEditorInterface(parent, flags) {};
 	void Signal_PropertyChanged(const QString & name, const QVariant & value) { QByteArray t6ae999 = name.toUtf8(); QtDesigner_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQDesignerPropertyEditorInterface_PropertyChanged(this, namePacked, const_cast<QVariant*>(&value)); };
 	void setObject(QObject * object) { callbackQDesignerPropertyEditorInterface_SetObject(this, object); };
 	void setPropertyValue(const QString & name, const QVariant & value, bool changed) { QByteArray t6ae999 = name.toUtf8(); QtDesigner_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQDesignerPropertyEditorInterface_SetPropertyValue(this, namePacked, const_cast<QVariant*>(&value), changed); };
@@ -5004,7 +5004,7 @@ void* QDesignerWidgetBoxInterface_MetaObjectDefault(void* ptr)
 class MyQExtensionFactory: public QExtensionFactory
 {
 public:
-	MyQExtensionFactory(QExtensionManager *parent) : QExtensionFactory(parent) {};
+	MyQExtensionFactory(QExtensionManager *parent = Q_NULLPTR) : QExtensionFactory(parent) {};
 	QObject * createExtension(QObject * object, const QString & iid, QObject * parent) const { QByteArray t52efa9 = iid.toUtf8(); QtDesigner_PackedString iidPacked = { const_cast<char*>(t52efa9.prepend("WHITESPACE").constData()+10), t52efa9.size()-10 };return static_cast<QObject*>(callbackQExtensionFactory_CreateExtension(const_cast<void*>(static_cast<const void*>(this)), object, iidPacked, parent)); };
 	QObject * extension(QObject * object, const QString & iid) const { QByteArray t52efa9 = iid.toUtf8(); QtDesigner_PackedString iidPacked = { const_cast<char*>(t52efa9.prepend("WHITESPACE").constData()+10), t52efa9.size()-10 };return static_cast<QObject*>(callbackQExtensionFactory_Extension(const_cast<void*>(static_cast<const void*>(this)), object, iidPacked)); };
 	bool event(QEvent * e) { return callbackQExtensionFactory_Event(this, e) != 0; };
@@ -5278,7 +5278,7 @@ void* QExtensionFactory_MetaObjectDefault(void* ptr)
 class MyQExtensionManager: public QExtensionManager
 {
 public:
-	MyQExtensionManager(QObject *parent) : QExtensionManager(parent) {};
+	MyQExtensionManager(QObject *parent = Q_NULLPTR) : QExtensionManager(parent) {};
 	void registerExtensions(QAbstractExtensionFactory * factory, const QString & iid) { QByteArray t52efa9 = iid.toUtf8(); QtDesigner_PackedString iidPacked = { const_cast<char*>(t52efa9.prepend("WHITESPACE").constData()+10), t52efa9.size()-10 };callbackQExtensionManager_RegisterExtensions(this, factory, iidPacked); };
 	void unregisterExtensions(QAbstractExtensionFactory * factory, const QString & iid) { QByteArray t52efa9 = iid.toUtf8(); QtDesigner_PackedString iidPacked = { const_cast<char*>(t52efa9.prepend("WHITESPACE").constData()+10), t52efa9.size()-10 };callbackQExtensionManager_UnregisterExtensions(this, factory, iidPacked); };
 	QObject * extension(QObject * object, const QString & iid) const { QByteArray t52efa9 = iid.toUtf8(); QtDesigner_PackedString iidPacked = { const_cast<char*>(t52efa9.prepend("WHITESPACE").constData()+10), t52efa9.size()-10 };return static_cast<QObject*>(callbackQExtensionManager_Extension(const_cast<void*>(static_cast<const void*>(this)), object, iidPacked)); };

gamepad/gamepad.cpp

@@ -42,7 +42,7 @@
 class MyQGamepad: public QGamepad
 {
 public:
-	MyQGamepad(int deviceId, QObject *parent) : QGamepad(deviceId, parent) {};
+	MyQGamepad(int deviceId = 0, QObject *parent = nullptr) : QGamepad(deviceId, parent) {};
 	void Signal_AxisLeftXChanged(double value) { callbackQGamepad_AxisLeftXChanged(this, value); };
 	void Signal_AxisLeftYChanged(double value) { callbackQGamepad_AxisLeftYChanged(this, value); };
 	void Signal_AxisRightXChanged(double value) { callbackQGamepad_AxisRightXChanged(this, value); };

gui/gui.cpp

@@ -1331,7 +1331,7 @@ int QAccessibleObject_IndexOfChildDefault(void* ptr, void* child)
 class MyQAccessiblePlugin: public QAccessiblePlugin
 {
 public:
-	MyQAccessiblePlugin(QObject *parent) : QAccessiblePlugin(parent) {};
+	MyQAccessiblePlugin(QObject *parent = Q_NULLPTR) : QAccessiblePlugin(parent) {};
 	QAccessibleInterface * create(const QString & key, QObject * object) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return static_cast<QAccessibleInterface*>(callbackQAccessiblePlugin_Create(this, keyPacked, object)); };
 	bool event(QEvent * e) { return callbackQAccessiblePlugin_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAccessiblePlugin_EventFilter(this, watched, event) != 0; };
@@ -2714,7 +2714,7 @@ void* QAccessibleValueInterface_MinimumValue(void* ptr)
 class MyQActionEvent: public QActionEvent
 {
 public:
-	MyQActionEvent(int type, QAction *action, QAction *before) : QActionEvent(type, action, before) {};
+	MyQActionEvent(int type, QAction *action, QAction *before = Q_NULLPTR) : QActionEvent(type, action, before) {};
 };
 
 void* QActionEvent_NewQActionEvent(int ty, void* action, void* before)
@@ -2813,7 +2813,7 @@ public:
 	MyQBitmap(const QBitmap &other) : QBitmap(other) {};
 	MyQBitmap(const QPixmap &pixmap) : QBitmap(pixmap) {};
 	MyQBitmap(const QSize &size) : QBitmap(size) {};
-	MyQBitmap(const QString &fileName, const char *format) : QBitmap(fileName, format) {};
+	MyQBitmap(const QString &fileName, const char *format = Q_NULLPTR) : QBitmap(fileName, format) {};
 	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
 	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
 };
@@ -4050,8 +4050,8 @@ void QDesktopServices_QDesktopServices_UnsetUrlHandler(char* scheme)
 class MyQDoubleValidator: public QDoubleValidator
 {
 public:
-	MyQDoubleValidator(QObject *parent) : QDoubleValidator(parent) {};
+	MyQDoubleValidator(QObject *parent = Q_NULLPTR) : QDoubleValidator(parent) {};
-	MyQDoubleValidator(double bottom, double top, int decimals, QObject *parent) : QDoubleValidator(bottom, top, decimals, parent) {};
+	MyQDoubleValidator(double bottom, double top, int decimals, QObject *parent = Q_NULLPTR) : QDoubleValidator(bottom, top, decimals, parent) {};
 	void setRange(double minimum, double maximum, int decimals) { callbackQDoubleValidator_SetRange(this, minimum, maximum, decimals); };
 	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQDoubleValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
 	void Signal_Changed() { callbackQValidator_Changed(this); };
@@ -4591,7 +4591,7 @@ void* QDragLeaveEvent_NewQDragLeaveEvent()
 class MyQDragMoveEvent: public QDragMoveEvent
 {
 public:
-	MyQDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type) : QDragMoveEvent(pos, actions, data, buttons, modifiers, type) {};
+	MyQDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove) : QDragMoveEvent(pos, actions, data, buttons, modifiers, type) {};
 };
 
 void* QDragMoveEvent_NewQDragMoveEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
@@ -4632,7 +4632,7 @@ void QDragMoveEvent_SetRect(void* ptr, void* vqr)
 class MyQDropEvent: public QDropEvent
 {
 public:
-	MyQDropEvent(const QPointF &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type) : QDropEvent(pos, actions, data, buttons, modifiers, type) {};
+	MyQDropEvent(const QPointF &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop) : QDropEvent(pos, actions, data, buttons, modifiers, type) {};
 };
 
 void* QDropEvent_NewQDropEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
@@ -4865,7 +4865,7 @@ char QFileOpenEvent_OpenFile(void* ptr, void* file, long long flags)
 class MyQFocusEvent: public QFocusEvent
 {
 public:
-	MyQFocusEvent(Type type, Qt::FocusReason reason) : QFocusEvent(type, reason) {};
+	MyQFocusEvent(Type type, Qt::FocusReason reason = Qt::OtherFocusReason) : QFocusEvent(type, reason) {};
 };
 
 void* QFocusEvent_NewQFocusEvent(long long ty, long long reason)
@@ -5870,7 +5870,7 @@ double QFontMetricsF_XHeight(void* ptr)
 class MyQGenericPlugin: public QGenericPlugin
 {
 public:
-	MyQGenericPlugin(QObject *parent) : QGenericPlugin(parent) {};
+	MyQGenericPlugin(QObject *parent = Q_NULLPTR) : QGenericPlugin(parent) {};
 	QObject * create(const QString & key, const QString & specification) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };QByteArray t03d6a1 = specification.toUtf8(); QtGui_PackedString specificationPacked = { const_cast<char*>(t03d6a1.prepend("WHITESPACE").constData()+10), t03d6a1.size()-10 };return static_cast<QObject*>(callbackQGenericPlugin_Create(this, keyPacked, specificationPacked)); };
 	bool event(QEvent * e) { return callbackQGenericPlugin_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGenericPlugin_EventFilter(this, watched, event) != 0; };
@@ -7070,7 +7070,7 @@ void* QHideEvent_NewQHideEvent()
 class MyQHoverEvent: public QHoverEvent
 {
 public:
-	MyQHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers) : QHoverEvent(type, pos, oldPos, modifiers) {};
+	MyQHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier) : QHoverEvent(type, pos, oldPos, modifiers) {};
 };
 
 void* QHoverEvent_NewQHoverEvent(long long ty, void* pos, void* oldPos, long long modifiers)
@@ -7454,7 +7454,7 @@ void* QIconEngine___availableSizes_newList(void* ptr)
 class MyQIconEnginePlugin: public QIconEnginePlugin
 {
 public:
-	MyQIconEnginePlugin(QObject *parent) : QIconEnginePlugin(parent) {};
+	MyQIconEnginePlugin(QObject *parent = Q_NULLPTR) : QIconEnginePlugin(parent) {};
 	QIconEngine * create(const QString & filename) { QByteArray t08deae = filename.toUtf8(); QtGui_PackedString filenamePacked = { const_cast<char*>(t08deae.prepend("WHITESPACE").constData()+10), t08deae.size()-10 };return static_cast<QIconEngine*>(callbackQIconEnginePlugin_Create(this, filenamePacked)); };
 	bool event(QEvent * e) { return callbackQIconEnginePlugin_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQIconEnginePlugin_EventFilter(this, watched, event) != 0; };
@@ -7697,7 +7697,7 @@ public:
 	MyQImage(QImage &&other) : QImage(other) {};
 	MyQImage(const QImage &image) : QImage(image) {};
 	MyQImage(const QSize &size, Format format) : QImage(size, format) {};
-	MyQImage(const QString &fileName, const char *format) : QImage(fileName, format) {};
+	MyQImage(const QString &fileName, const char *format = Q_NULLPTR) : QImage(fileName, format) {};
 	MyQImage(int width, int height, Format format) : QImage(width, height, format) {};
 	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQImage_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
 	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
@@ -8296,7 +8296,7 @@ void QImageIOHandler_SetFormat2(void* ptr, void* format)
 class MyQImageIOPlugin: public QImageIOPlugin
 {
 public:
-	MyQImageIOPlugin(QObject *parent) : QImageIOPlugin(parent) {};
+	MyQImageIOPlugin(QObject *parent = Q_NULLPTR) : QImageIOPlugin(parent) {};
 	 ~MyQImageIOPlugin() { callbackQImageIOPlugin_DestroyQImageIOPlugin(this); };
 	Capabilities capabilities(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOPlugin::Capability>(callbackQImageIOPlugin_Capabilities(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
 	QImageIOHandler * create(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOHandler*>(callbackQImageIOPlugin_Create(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
@@ -9625,8 +9625,8 @@ long long QInputMethodQueryEvent_Queries(void* ptr)
 class MyQIntValidator: public QIntValidator
 {
 public:
-	MyQIntValidator(QObject *parent) : QIntValidator(parent) {};
+	MyQIntValidator(QObject *parent = Q_NULLPTR) : QIntValidator(parent) {};
-	MyQIntValidator(int minimum, int maximum, QObject *parent) : QIntValidator(minimum, maximum, parent) {};
+	MyQIntValidator(int minimum, int maximum, QObject *parent = Q_NULLPTR) : QIntValidator(minimum, maximum, parent) {};
 	void setRange(int bottom, int top) { callbackQIntValidator_SetRange(this, bottom, top); };
 	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQIntValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
 	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
@@ -9774,8 +9774,8 @@ int QIntValidator_Top(void* ptr)
 class MyQKeyEvent: public QKeyEvent
 {
 public:
-	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text, bool autorep, ushort count) : QKeyEvent(type, key, modifiers, text, autorep, count) {};
+	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text = QString(), bool autorep = false, ushort count = 1) : QKeyEvent(type, key, modifiers, text, autorep, count) {};
-	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text, bool autorep, ushort count) : QKeyEvent(type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count) {};
+	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text = QString(), bool autorep = false, ushort count = 1) : QKeyEvent(type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count) {};
 };
 
 void* QKeyEvent_NewQKeyEvent(long long ty, int key, long long modifiers, char* text, char autorep, unsigned short count)
@@ -10451,9 +10451,9 @@ void* QMoveEvent_Pos(void* ptr)
 class MyQMovie: public QMovie
 {
 public:
-	MyQMovie(QIODevice *device, const QByteArray &format, QObject *parent) : QMovie(device, format, parent) {};
+	MyQMovie(QIODevice *device, const QByteArray &format = QByteArray(), QObject *parent = Q_NULLPTR) : QMovie(device, format, parent) {};
-	MyQMovie(QObject *parent) : QMovie(parent) {};
+	MyQMovie(QObject *parent = Q_NULLPTR) : QMovie(parent) {};
-	MyQMovie(const QString &fileName, const QByteArray &format, QObject *parent) : QMovie(fileName, format, parent) {};
+	MyQMovie(const QString &fileName, const QByteArray &format = QByteArray(), QObject *parent = Q_NULLPTR) : QMovie(fileName, format, parent) {};
 	bool jumpToNextFrame() { return callbackQMovie_JumpToNextFrame(this) != 0; };
 	void Signal_Error(QImageReader::ImageReaderError error) { callbackQMovie_Error(this, error); };
 	void Signal_Finished() { callbackQMovie_Finished(this); };
@@ -11188,7 +11188,7 @@ void QNativeGestureEvent_SetMWindowPos(void* ptr, void* vqp)
 class MyQOffscreenSurface: public QOffscreenSurface
 {
 public:
-	MyQOffscreenSurface(QScreen *targetScreen) : QOffscreenSurface(targetScreen) {};
+	MyQOffscreenSurface(QScreen *targetScreen = Q_NULLPTR) : QOffscreenSurface(targetScreen) {};
 	void Signal_ScreenChanged(QScreen * screen) { callbackQOffscreenSurface_ScreenChanged(this, screen); };
 	 ~MyQOffscreenSurface() { callbackQOffscreenSurface_DestroyQOffscreenSurface(this); };
 	QSize size() const { return *static_cast<QSize*>(callbackQOffscreenSurface_Size(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -12388,7 +12388,7 @@ void* QPaintDeviceWindow_PaintEngineDefault(void* ptr)
 class MyQPaintEngine: public QPaintEngine
 {
 public:
-	MyQPaintEngine(PaintEngineFeatures caps) : QPaintEngine(caps) {};
+	MyQPaintEngine(PaintEngineFeatures caps = PaintEngineFeatures()) : QPaintEngine(caps) {};
 	bool end() { return callbackQPaintEngine_End(this) != 0; };
 	void drawEllipse(const QRectF & rect) { callbackQPaintEngine_DrawEllipse(this, const_cast<QRectF*>(&rect)); };
 	void drawImage(const QRectF & rectangle, const QImage & image, const QRectF & sr, Qt::ImageConversionFlags flags) { callbackQPaintEngine_DrawImage(this, const_cast<QRectF*>(&rectangle), const_cast<QImage*>(&image), const_cast<QRectF*>(&sr), flags); };
@@ -15055,7 +15055,7 @@ class MyQPicture: public QPicture
 {
 public:
 	MyQPicture(const QPicture &pic) : QPicture(pic) {};
-	MyQPicture(int formatVersion) : QPicture(formatVersion) {};
+	MyQPicture(int formatVersion = -1) : QPicture(formatVersion) {};
 	void setData(const char * data, uint size) { QtGui_PackedString dataPacked = { const_cast<char*>(data), size };callbackQPicture_SetData(this, dataPacked, size); };
 	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPicture_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
 	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
@@ -15302,7 +15302,7 @@ public:
 	MyQPixmap() : QPixmap() {};
 	MyQPixmap(const QPixmap &pixmap) : QPixmap(pixmap) {};
 	MyQPixmap(const QSize &size) : QPixmap(size) {};
-	MyQPixmap(const QString &fileName, const char *format, Qt::ImageConversionFlags flags) : QPixmap(fileName, format, flags) {};
+	MyQPixmap(const QString &fileName, const char *format = Q_NULLPTR, Qt::ImageConversionFlags flags = Qt::AutoColor) : QPixmap(fileName, format, flags) {};
 	MyQPixmap(int width, int height) : QPixmap(width, height) {};
 	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
 	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
@@ -16696,7 +16696,7 @@ double QRadialGradient_Radius(void* ptr)
 class MyQRasterWindow: public QRasterWindow
 {
 public:
-	MyQRasterWindow(QWindow *parent) : QRasterWindow(parent) {};
+	MyQRasterWindow(QWindow *parent = Q_NULLPTR) : QRasterWindow(parent) {};
 	void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
 	void update() { callbackQPaintDeviceWindow_Update3(this); };
 	bool close() { return callbackQWindow_Close(this) != 0; };
@@ -17077,8 +17077,8 @@ void* QRawFont___glyphIndexesForString_newList(void* ptr)
 class MyQRegExpValidator: public QRegExpValidator
 {
 public:
-	MyQRegExpValidator(QObject *parent) : QRegExpValidator(parent) {};
+	MyQRegExpValidator(QObject *parent = Q_NULLPTR) : QRegExpValidator(parent) {};
-	MyQRegExpValidator(const QRegExp &rx, QObject *parent) : QRegExpValidator(rx, parent) {};
+	MyQRegExpValidator(const QRegExp &rx, QObject *parent = Q_NULLPTR) : QRegExpValidator(rx, parent) {};
 	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegExpValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
 	void Signal_Changed() { callbackQValidator_Changed(this); };
 	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
@@ -17360,8 +17360,8 @@ void* QRegion___rects_newList(void* ptr)
 class MyQRegularExpressionValidator: public QRegularExpressionValidator
 {
 public:
-	MyQRegularExpressionValidator(QObject *parent) : QRegularExpressionValidator(parent) {};
+	MyQRegularExpressionValidator(QObject *parent = Q_NULLPTR) : QRegularExpressionValidator(parent) {};
-	MyQRegularExpressionValidator(const QRegularExpression &re, QObject *parent) : QRegularExpressionValidator(re, parent) {};
+	MyQRegularExpressionValidator(const QRegularExpression &re, QObject *parent = Q_NULLPTR) : QRegularExpressionValidator(re, parent) {};
 	void Signal_RegularExpressionChanged(const QRegularExpression & re) { callbackQRegularExpressionValidator_RegularExpressionChanged(this, const_cast<QRegularExpression*>(&re)); };
 	void setRegularExpression(const QRegularExpression & re) { callbackQRegularExpressionValidator_SetRegularExpression(this, const_cast<QRegularExpression*>(&re)); };
 	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegularExpressionValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
@@ -18464,7 +18464,7 @@ void* QSessionManager_MetaObjectDefault(void* ptr)
 class MyQShortcutEvent: public QShortcutEvent
 {
 public:
-	MyQShortcutEvent(const QKeySequence &key, int id, bool ambiguous) : QShortcutEvent(key, id, ambiguous) {};
+	MyQShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false) : QShortcutEvent(key, id, ambiguous) {};
 };
 
 void* QShortcutEvent_NewQShortcutEvent(void* key, int id, char ambiguous)
@@ -18540,7 +18540,7 @@ public:
 	MyQStandardItem(const QIcon &icon, const QString &text) : QStandardItem(icon, text) {};
 	MyQStandardItem(const QStandardItem &other) : QStandardItem(other) {};
 	MyQStandardItem(const QString &text) : QStandardItem(text) {};
-	MyQStandardItem(int rows, int columns) : QStandardItem(rows, columns) {};
+	MyQStandardItem(int rows, int columns = 1) : QStandardItem(rows, columns) {};
 	void read(QDataStream & in) { callbackQStandardItem_Read(this, static_cast<QDataStream*>(&in)); };
 	void setData(const QVariant & value, int role) { callbackQStandardItem_SetData(this, const_cast<QVariant*>(&value), role); };
 	 ~MyQStandardItem() { callbackQStandardItem_DestroyQStandardItem(this); };
@@ -19148,8 +19148,8 @@ void* QStandardItem___insertRows_items_newList(void* ptr)
 class MyQStandardItemModel: public QStandardItemModel
 {
 public:
-	MyQStandardItemModel(QObject *parent) : QStandardItemModel(parent) {};
+	MyQStandardItemModel(QObject *parent = Q_NULLPTR) : QStandardItemModel(parent) {};
-	MyQStandardItemModel(int rows, int columns, QObject *parent) : QStandardItemModel(rows, columns, parent) {};
+	MyQStandardItemModel(int rows, int columns, QObject *parent = Q_NULLPTR) : QStandardItemModel(rows, columns, parent) {};
 	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQStandardItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
@@ -22549,8 +22549,8 @@ void QTextCursor_SelectedTableCells(void* ptr, int firstRow, int numRows, int fi
 class MyQTextDocument: public QTextDocument
 {
 public:
-	MyQTextDocument(const QString &text, QObject *parent) : QTextDocument(text, parent) {};
+	MyQTextDocument(const QString &text, QObject *parent = Q_NULLPTR) : QTextDocument(text, parent) {};
-	MyQTextDocument(QObject *parent) : QTextDocument(parent) {};
+	MyQTextDocument(QObject *parent = Q_NULLPTR) : QTextDocument(parent) {};
 	QTextObject * createObject(const QTextFormat & format) { return static_cast<QTextObject*>(callbackQTextDocument_CreateObject(this, const_cast<QTextFormat*>(&format))); };
 	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextDocument_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
 	void Signal_BaseUrlChanged(const QUrl & url) { callbackQTextDocument_BaseUrlChanged(this, const_cast<QUrl*>(&url)); };
@@ -26066,7 +26066,7 @@ void QTransform_Map(void* ptr, double x, double y, double tx, double ty)
 class MyQValidator: public QValidator
 {
 public:
-	MyQValidator(QObject *parent) : QValidator(parent) {};
+	MyQValidator(QObject *parent = Q_NULLPTR) : QValidator(parent) {};
 	void Signal_Changed() { callbackQValidator_Changed(this); };
 	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
 	State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
@@ -27082,7 +27082,7 @@ void QWheelEvent_SetQt4O(void* ptr, long long vqt)
 class MyQWindow: public QWindow
 {
 public:
-	MyQWindow(QScreen *targetScreen) : QWindow(targetScreen) {};
+	MyQWindow(QScreen *targetScreen = Q_NULLPTR) : QWindow(targetScreen) {};
 	MyQWindow(QWindow *parent) : QWindow(parent) {};
 	bool close() { return callbackQWindow_Close(this) != 0; };
 	bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };

help/help.cpp

@@ -1743,7 +1743,7 @@ void* QHelpContentWidget_MetaObjectDefault(void* ptr)
 class MyQHelpEngine: public QHelpEngine
 {
 public:
-	MyQHelpEngine(const QString &collectionFile, QObject *parent) : QHelpEngine(collectionFile, parent) {};
+	MyQHelpEngine(const QString &collectionFile, QObject *parent = Q_NULLPTR) : QHelpEngine(collectionFile, parent) {};
 	void Signal_CurrentFilterChanged(const QString & newFilter) { QByteArray t56548b = newFilter.toUtf8(); QtHelp_PackedString newFilterPacked = { const_cast<char*>(t56548b.prepend("WHITESPACE").constData()+10), t56548b.size()-10 };callbackQHelpEngineCore_CurrentFilterChanged(this, newFilterPacked); };
 	void Signal_ReadersAboutToBeInvalidated() { callbackQHelpEngineCore_ReadersAboutToBeInvalidated(this); };
 	void Signal_SetupFinished() { callbackQHelpEngineCore_SetupFinished(this); };
@@ -1836,7 +1836,7 @@ void* QHelpEngine_IndexModel(void* ptr)
 class MyQHelpEngineCore: public QHelpEngineCore
 {
 public:
-	MyQHelpEngineCore(const QString &collectionFile, QObject *parent) : QHelpEngineCore(collectionFile, parent) {};
+	MyQHelpEngineCore(const QString &collectionFile, QObject *parent = Q_NULLPTR) : QHelpEngineCore(collectionFile, parent) {};
 	void Signal_CurrentFilterChanged(const QString & newFilter) { QByteArray t56548b = newFilter.toUtf8(); QtHelp_PackedString newFilterPacked = { const_cast<char*>(t56548b.prepend("WHITESPACE").constData()+10), t56548b.size()-10 };callbackQHelpEngineCore_CurrentFilterChanged(this, newFilterPacked); };
 	void Signal_ReadersAboutToBeInvalidated() { callbackQHelpEngineCore_ReadersAboutToBeInvalidated(this); };
 	void Signal_SetupFinished() { callbackQHelpEngineCore_SetupFinished(this); };
@@ -3957,7 +3957,7 @@ void* QHelpIndexWidget_MetaObjectDefault(void* ptr)
 class MyQHelpSearchEngine: public QHelpSearchEngine
 {
 public:
-	MyQHelpSearchEngine(QHelpEngineCore *helpEngine, QObject *parent) : QHelpSearchEngine(helpEngine, parent) {};
+	MyQHelpSearchEngine(QHelpEngineCore *helpEngine, QObject *parent = Q_NULLPTR) : QHelpSearchEngine(helpEngine, parent) {};
 	void cancelIndexing() { callbackQHelpSearchEngine_CancelIndexing(this); };
 	void cancelSearching() { callbackQHelpSearchEngine_CancelSearching(this); };
 	void Signal_IndexingFinished() { callbackQHelpSearchEngine_IndexingFinished(this); };
@@ -4323,7 +4323,7 @@ void QHelpSearchQuery_SetWordList(void* ptr, char* vqs)
 class MyQHelpSearchQueryWidget: public QHelpSearchQueryWidget
 {
 public:
-	MyQHelpSearchQueryWidget(QWidget *parent) : QHelpSearchQueryWidget(parent) {};
+	MyQHelpSearchQueryWidget(QWidget *parent = Q_NULLPTR) : QHelpSearchQueryWidget(parent) {};
 	void Signal_Search() { callbackQHelpSearchQueryWidget_Search(this); };
 	bool close() { return callbackQHelpSearchQueryWidget_Close(this) != 0; };
 	bool event(QEvent * event) { return callbackQHelpSearchQueryWidget_Event(this, event) != 0; };

internal/binding/parser/class_add.go

@@ -219,19 +219,16 @@ func (c *Class) addMocFuncs() {
 	}
 	c.Functions = append(c.Functions, tmpF)
 
-	/*
+	//int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
-		//TODO:
+	tmpF2 = *tmpF
-		//int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
+	tmpF2.Overload = true
-		tmpF2 = *tmpF
+	tmpF2.OverloadNumber = "2"
-		tmpF2.Overload = true
+	tmpF2.Parameters = []*Parameter{
-		tmpF2.OverloadNumber = "2"
+		{Name: "uri", Value: "const char *"},
-		tmpF2.Parameters = []*Parameter{
+		{Name: "versionMajor", Value: "int"},
-			{Name: "uri", Value: "const char *"},
+		{Name: "versionMinor", Value: "int"},
-			{Name: "versionMajor", Value: "int"},
+		{Name: "qmlName", Value: "const char *"},
-			{Name: "versionMinor", Value: "int"},
+	}
-			{Name: "qmlName", Value: "const char *"},
+	tmpF2.Signature = "(const char *uri, int versionMajor, int versionMinor, const char *qmlName)"
-		}
+	c.Functions = append(c.Functions, &tmpF2)
-		tmpF2.Signature = "(const char *uri, int versionMajor, int versionMinor, const char *qmlName)"
-		c.Functions = append(c.Functions, &tmpF2)
-	*/
 }

internal/binding/parser/function.go

@@ -43,8 +43,10 @@ type Function struct {
 }
 
 type Parameter struct {
-	Name  string `xml:"name,attr"`
+	Name    string `xml:"name,attr"`
-	Value string `xml:"left,attr"`
+	Value   string `xml:"left,attr"`
+	Right   string `xml:"right,attr"`
+	Default string `xml:"default,attr"`
 }
 
 func (f *Function) Class() (*Class, bool) {

internal/binding/templater/template_cpp.go

@@ -144,7 +144,25 @@ func CppTemplate(module string, mode int, target string) []byte {
 
 							function.ClassName(),
 
-							strings.Split(strings.Split(function.Signature, "(")[1], ")")[0],
+							func() string {
+								var input []string
+								for _, p := range function.OgParameters {
+									if p.Default != "" {
+										if strings.HasSuffix(p.Value, "*") || strings.HasSuffix(p.Value, "&") {
+											input = append(input, p.Value+p.Name+" = "+p.Default)
+										} else {
+											input = append(input, p.Value+" "+p.Name+" = "+p.Default)
+										}
+									} else {
+										if strings.HasSuffix(p.Value, "*") || strings.HasSuffix(p.Value, "&") {
+											input = append(input, p.Value+p.Name)
+										} else {
+											input = append(input, p.Value+" "+p.Name)
+										}
+									}
+								}
+								return strings.Join(input, ", ")
+							}(),
 
 							func() string {
 								if mode == MOC {

location/location.cpp

@@ -260,8 +260,8 @@ void* QGeoRoute___path_newList(void* ptr)
 class MyQGeoRouteReply: public QGeoRouteReply
 {
 public:
-	MyQGeoRouteReply(Error error, const QString &errorString, QObject *parent) : QGeoRouteReply(error, errorString, parent) {};
+	MyQGeoRouteReply(Error error, const QString &errorString, QObject *parent = Q_NULLPTR) : QGeoRouteReply(error, errorString, parent) {};
-	MyQGeoRouteReply(const QGeoRouteRequest &request, QObject *parent) : QGeoRouteReply(request, parent) {};
+	MyQGeoRouteReply(const QGeoRouteRequest &request, QObject *parent = Q_NULLPTR) : QGeoRouteReply(request, parent) {};
 	void abort() { callbackQGeoRouteReply_Abort(this); };
 	void Signal_Error2(QGeoRouteReply::Error error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtLocation_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQGeoRouteReply_Error2(this, error, errorStringPacked); };
 	void Signal_Finished() { callbackQGeoRouteReply_Finished(this); };
@@ -1142,7 +1142,7 @@ void* QGeoRoutingManager_MetaObjectDefault(void* ptr)
 class MyQGeoRoutingManagerEngine: public QGeoRoutingManagerEngine
 {
 public:
-	MyQGeoRoutingManagerEngine(const QVariantMap &parameters, QObject *parent) : QGeoRoutingManagerEngine(parameters, parent) {};
+	MyQGeoRoutingManagerEngine(const QVariantMap &parameters, QObject *parent = Q_NULLPTR) : QGeoRoutingManagerEngine(parameters, parent) {};
 	QGeoRouteReply * calculateRoute(const QGeoRouteRequest & request) { return static_cast<QGeoRouteReply*>(callbackQGeoRoutingManagerEngine_CalculateRoute(this, const_cast<QGeoRouteRequest*>(&request))); };
 	QGeoRouteReply * updateRoute(const QGeoRoute & route, const QGeoCoordinate & position) { return static_cast<QGeoRouteReply*>(callbackQGeoRoutingManagerEngine_UpdateRoute(this, const_cast<QGeoRoute*>(&route), const_cast<QGeoCoordinate*>(&position))); };
 	void Signal_Error(QGeoRouteReply * reply, QGeoRouteReply::Error error, QString errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtLocation_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQGeoRoutingManagerEngine_Error(this, reply, error, errorStringPacked); };
@@ -1505,7 +1505,7 @@ void* QGeoRoutingManagerEngine_MetaObjectDefault(void* ptr)
 class MyQGeoServiceProvider: public QGeoServiceProvider
 {
 public:
-	MyQGeoServiceProvider(const QString &providerName, const QVariantMap &parameters, bool allowExperimental) : QGeoServiceProvider(providerName, parameters, allowExperimental) {};
+	MyQGeoServiceProvider(const QString &providerName, const QVariantMap &parameters = QVariantMap(), bool allowExperimental = false) : QGeoServiceProvider(providerName, parameters, allowExperimental) {};
 	bool event(QEvent * e) { return callbackQGeoServiceProvider_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGeoServiceProvider_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQGeoServiceProvider_ChildEvent(this, event); };

macextras/macextras.cpp

@@ -152,8 +152,8 @@ void* QMacPasteboardMime___convertToMime_data_newList(void* ptr)
 class MyQMacToolBar: public QMacToolBar
 {
 public:
-	MyQMacToolBar(QObject *parent) : QMacToolBar(parent) {};
+	MyQMacToolBar(QObject *parent = Q_NULLPTR) : QMacToolBar(parent) {};
-	MyQMacToolBar(const QString &identifier, QObject *parent) : QMacToolBar(identifier, parent) {};
+	MyQMacToolBar(const QString &identifier, QObject *parent = Q_NULLPTR) : QMacToolBar(identifier, parent) {};
 	bool event(QEvent * e) { return callbackQMacToolBar_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMacToolBar_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQMacToolBar_ChildEvent(this, event); };
@@ -506,7 +506,7 @@ void* QMacToolBar_MetaObjectDefault(void* ptr)
 class MyQMacToolBarItem: public QMacToolBarItem
 {
 public:
-	MyQMacToolBarItem(QObject *parent) : QMacToolBarItem(parent) {};
+	MyQMacToolBarItem(QObject *parent = Q_NULLPTR) : QMacToolBarItem(parent) {};
 	void Signal_Activated() { callbackQMacToolBarItem_Activated(this); };
 	 ~MyQMacToolBarItem() { callbackQMacToolBarItem_DestroyQMacToolBarItem(this); };
 	bool event(QEvent * e) { return callbackQMacToolBarItem_Event(this, e) != 0; };

multimedia/multimedia.cpp

@@ -311,7 +311,7 @@ void QAbstractVideoBuffer_SetM_type(void* ptr, long long vha)
 class MyQAbstractVideoFilter: public QAbstractVideoFilter
 {
 public:
-	MyQAbstractVideoFilter(QObject *parent) : QAbstractVideoFilter(parent) {};
+	MyQAbstractVideoFilter(QObject *parent = Q_NULLPTR) : QAbstractVideoFilter(parent) {};
 	QVideoFilterRunnable * createFilterRunnable() { return static_cast<QVideoFilterRunnable*>(callbackQAbstractVideoFilter_CreateFilterRunnable(this)); };
 	void Signal_ActiveChanged() { callbackQAbstractVideoFilter_ActiveChanged(this); };
 	bool event(QEvent * e) { return callbackQAbstractVideoFilter_Event(this, e) != 0; };
@@ -591,7 +591,7 @@ void* QAbstractVideoFilter_MetaObjectDefault(void* ptr)
 class MyQAbstractVideoSurface: public QAbstractVideoSurface
 {
 public:
-	MyQAbstractVideoSurface(QObject *parent) : QAbstractVideoSurface(parent) {};
+	MyQAbstractVideoSurface(QObject *parent = Q_NULLPTR) : QAbstractVideoSurface(parent) {};
 	void stop() { callbackQAbstractVideoSurface_Stop(this); };
 	bool present(const QVideoFrame & frame) { return callbackQAbstractVideoSurface_Present(this, const_cast<QVideoFrame*>(&frame)) != 0; };
 	bool start(const QVideoSurfaceFormat & format) { return callbackQAbstractVideoSurface_Start(this, const_cast<QVideoSurfaceFormat*>(&format)) != 0; };
@@ -1104,7 +1104,7 @@ long long QAudioBuffer_StartTime(void* ptr)
 class MyQAudioDecoder: public QAudioDecoder
 {
 public:
-	MyQAudioDecoder(QObject *parent) : QAudioDecoder(parent) {};
+	MyQAudioDecoder(QObject *parent = Q_NULLPTR) : QAudioDecoder(parent) {};
 	void Signal_BufferAvailableChanged(bool available) { callbackQAudioDecoder_BufferAvailableChanged(this, available); };
 	void Signal_BufferReady() { callbackQAudioDecoder_BufferReady(this); };
 	void Signal_DurationChanged(qint64 duration) { callbackQAudioDecoder_DurationChanged(this, duration); };
@@ -1414,7 +1414,7 @@ long long QAudioDecoder_Position(void* ptr)
 class MyQAudioDecoderControl: public QAudioDecoderControl
 {
 public:
-	MyQAudioDecoderControl(QObject *parent) : QAudioDecoderControl(parent) {};
+	MyQAudioDecoderControl(QObject *parent = Q_NULLPTR) : QAudioDecoderControl(parent) {};
 	QAudioBuffer read() { return *static_cast<QAudioBuffer*>(callbackQAudioDecoderControl_Read(this)); };
 	void Signal_BufferAvailableChanged(bool available) { callbackQAudioDecoderControl_BufferAvailableChanged(this, available); };
 	void Signal_BufferReady() { callbackQAudioDecoderControl_BufferReady(this); };
@@ -2044,7 +2044,7 @@ void* QAudioEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
 class MyQAudioEncoderSettingsControl: public QAudioEncoderSettingsControl
 {
 public:
-	MyQAudioEncoderSettingsControl(QObject *parent) : QAudioEncoderSettingsControl(parent) {};
+	MyQAudioEncoderSettingsControl(QObject *parent = Q_NULLPTR) : QAudioEncoderSettingsControl(parent) {};
 	void setAudioSettings(const QAudioEncoderSettings & settings) { callbackQAudioEncoderSettingsControl_SetAudioSettings(this, const_cast<QAudioEncoderSettings*>(&settings)); };
 	 ~MyQAudioEncoderSettingsControl() { callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(this); };
 	QAudioEncoderSettings audioSettings() const { return *static_cast<QAudioEncoderSettings*>(callbackQAudioEncoderSettingsControl_AudioSettings(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -2273,8 +2273,8 @@ long long QAudioFormat_DurationForFrames(void* ptr, int frameCount)
 class MyQAudioInput: public QAudioInput
 {
 public:
-	MyQAudioInput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format, QObject *parent) : QAudioInput(audioDevice, format, parent) {};
+	MyQAudioInput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioInput(audioDevice, format, parent) {};
-	MyQAudioInput(const QAudioFormat &format, QObject *parent) : QAudioInput(format, parent) {};
+	MyQAudioInput(const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioInput(format, parent) {};
 	void Signal_StateChanged(QAudio::State state) { callbackQAudioInput_StateChanged(this, state); };
 	bool event(QEvent * e) { return callbackQAudioInput_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioInput_EventFilter(this, watched, event) != 0; };
@@ -2777,8 +2777,8 @@ void* QAudioInputSelectorControl___availableInputs_newList(void* ptr)
 class MyQAudioOutput: public QAudioOutput
 {
 public:
-	MyQAudioOutput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format, QObject *parent) : QAudioOutput(audioDevice, format, parent) {};
+	MyQAudioOutput(const QAudioDeviceInfo &audioDevice, const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioOutput(audioDevice, format, parent) {};
-	MyQAudioOutput(const QAudioFormat &format, QObject *parent) : QAudioOutput(format, parent) {};
+	MyQAudioOutput(const QAudioFormat &format = QAudioFormat(), QObject *parent = Q_NULLPTR) : QAudioOutput(format, parent) {};
 	void Signal_StateChanged(QAudio::State state) { callbackQAudioOutput_StateChanged(this, state); };
 	bool event(QEvent * e) { return callbackQAudioOutput_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAudioOutput_EventFilter(this, watched, event) != 0; };
@@ -3291,7 +3291,7 @@ void* QAudioOutputSelectorControl___availableOutputs_newList(void* ptr)
 class MyQAudioProbe: public QAudioProbe
 {
 public:
-	MyQAudioProbe(QObject *parent) : QAudioProbe(parent) {};
+	MyQAudioProbe(QObject *parent = Q_NULLPTR) : QAudioProbe(parent) {};
 	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQAudioProbe_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
 	void Signal_Flush() { callbackQAudioProbe_Flush(this); };
 	bool event(QEvent * e) { return callbackQAudioProbe_Event(this, e) != 0; };
@@ -3591,7 +3591,7 @@ void* QAudioProbe_MetaObjectDefault(void* ptr)
 class MyQAudioRecorder: public QAudioRecorder
 {
 public:
-	MyQAudioRecorder(QObject *parent) : QAudioRecorder(parent) {};
+	MyQAudioRecorder(QObject *parent = Q_NULLPTR) : QAudioRecorder(parent) {};
 	void Signal_AudioInputChanged(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioRecorder_AudioInputChanged(this, namePacked); };
 	void Signal_AvailableAudioInputsChanged() { callbackQAudioRecorder_AvailableAudioInputsChanged(this); };
 	void setAudioInput(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQAudioRecorder_SetAudioInput(this, namePacked); };
@@ -3737,7 +3737,7 @@ struct QtMultimedia_PackedString QAudioRecorder_AudioInputs(void* ptr)
 class MyQAudioRoleControl: public QAudioRoleControl
 {
 public:
-	MyQAudioRoleControl(QObject *parent) : QAudioRoleControl(parent) {};
+	MyQAudioRoleControl(QObject *parent = Q_NULLPTR) : QAudioRoleControl(parent) {};
 	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQAudioRoleControl_AudioRoleChanged(this, role); };
 	void setAudioRole(QAudio::Role role) { callbackQAudioRoleControl_SetAudioRole(this, role); };
 	 ~MyQAudioRoleControl() { callbackQAudioRoleControl_DestroyQAudioRoleControl(this); };
@@ -3855,10 +3855,10 @@ void* QAudioRoleControl___supportedAudioRoles_newList(void* ptr)
 class MyQCamera: public QCamera
 {
 public:
-	MyQCamera(QCamera::Position position, QObject *parent) : QCamera(position, parent) {};
+	MyQCamera(QCamera::Position position, QObject *parent = Q_NULLPTR) : QCamera(position, parent) {};
-	MyQCamera(QObject *parent) : QCamera(parent) {};
+	MyQCamera(QObject *parent = Q_NULLPTR) : QCamera(parent) {};
-	MyQCamera(const QByteArray &deviceName, QObject *parent) : QCamera(deviceName, parent) {};
+	MyQCamera(const QByteArray &deviceName, QObject *parent = Q_NULLPTR) : QCamera(deviceName, parent) {};
-	MyQCamera(const QCameraInfo &cameraInfo, QObject *parent) : QCamera(cameraInfo, parent) {};
+	MyQCamera(const QCameraInfo &cameraInfo, QObject *parent = Q_NULLPTR) : QCamera(cameraInfo, parent) {};
 	void Signal_CaptureModeChanged(QCamera::CaptureModes mode) { callbackQCamera_CaptureModeChanged(this, mode); };
 	void Signal_Error2(QCamera::Error value) { callbackQCamera_Error2(this, value); };
 	void load() { callbackQCamera_Load(this); };
@@ -4447,7 +4447,7 @@ void* QCamera___supportedViewfinderPixelFormats_newList(void* ptr)
 class MyQCameraCaptureBufferFormatControl: public QCameraCaptureBufferFormatControl
 {
 public:
-	MyQCameraCaptureBufferFormatControl(QObject *parent) : QCameraCaptureBufferFormatControl(parent) {};
+	MyQCameraCaptureBufferFormatControl(QObject *parent = Q_NULLPTR) : QCameraCaptureBufferFormatControl(parent) {};
 	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraCaptureBufferFormatControl_BufferFormatChanged(this, format); };
 	void setBufferFormat(QVideoFrame::PixelFormat format) { callbackQCameraCaptureBufferFormatControl_SetBufferFormat(this, format); };
 	QList<QVideoFrame::PixelFormat> supportedBufferFormats() const { return *static_cast<QList<QVideoFrame::PixelFormat>*>(callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -4559,7 +4559,7 @@ void* QCameraCaptureBufferFormatControl___supportedBufferFormats_newList(void* p
 class MyQCameraCaptureDestinationControl: public QCameraCaptureDestinationControl
 {
 public:
-	MyQCameraCaptureDestinationControl(QObject *parent) : QCameraCaptureDestinationControl(parent) {};
+	MyQCameraCaptureDestinationControl(QObject *parent = Q_NULLPTR) : QCameraCaptureDestinationControl(parent) {};
 	void Signal_CaptureDestinationChanged(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_CaptureDestinationChanged(this, destination); };
 	void setCaptureDestination(QCameraImageCapture::CaptureDestinations destination) { callbackQCameraCaptureDestinationControl_SetCaptureDestination(this, destination); };
 	QCameraImageCapture::CaptureDestinations captureDestination() const { return static_cast<QCameraImageCapture::CaptureDestination>(callbackQCameraCaptureDestinationControl_CaptureDestination(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -4656,7 +4656,7 @@ char QCameraCaptureDestinationControl_IsCaptureDestinationSupported(void* ptr, l
 class MyQCameraControl: public QCameraControl
 {
 public:
-	MyQCameraControl(QObject *parent) : QCameraControl(parent) {};
+	MyQCameraControl(QObject *parent = Q_NULLPTR) : QCameraControl(parent) {};
 	void Signal_CaptureModeChanged(QCamera::CaptureModes mode) { callbackQCameraControl_CaptureModeChanged(this, mode); };
 	void Signal_Error(int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQCameraControl_Error(this, error, errorStringPacked); };
 	void setCaptureMode(QCamera::CaptureModes mode) { callbackQCameraControl_SetCaptureMode(this, mode); };
@@ -5398,7 +5398,7 @@ void* QCameraExposure_MetaObjectDefault(void* ptr)
 class MyQCameraExposureControl: public QCameraExposureControl
 {
 public:
-	MyQCameraExposureControl(QObject *parent) : QCameraExposureControl(parent) {};
+	MyQCameraExposureControl(QObject *parent = Q_NULLPTR) : QCameraExposureControl(parent) {};
 	bool setValue(QCameraExposureControl::ExposureParameter parameter, const QVariant & value) { return callbackQCameraExposureControl_SetValue(this, parameter, const_cast<QVariant*>(&value)) != 0; };
 	void Signal_ActualValueChanged(int parameter) { callbackQCameraExposureControl_ActualValueChanged(this, parameter); };
 	void Signal_ParameterRangeChanged(int parameter) { callbackQCameraExposureControl_ParameterRangeChanged(this, parameter); };
@@ -5554,7 +5554,7 @@ void* QCameraExposureControl___supportedParameterRange_newList(void* ptr)
 class MyQCameraFeedbackControl: public QCameraFeedbackControl
 {
 public:
-	MyQCameraFeedbackControl(QObject *parent) : QCameraFeedbackControl(parent) {};
+	MyQCameraFeedbackControl(QObject *parent = Q_NULLPTR) : QCameraFeedbackControl(parent) {};
 	bool setEventFeedbackEnabled(QCameraFeedbackControl::EventType event, bool enabled) { return callbackQCameraFeedbackControl_SetEventFeedbackEnabled(this, event, enabled) != 0; };
 	bool setEventFeedbackSound(QCameraFeedbackControl::EventType event, const QString & filePath) { QByteArray t7df503 = filePath.toUtf8(); QtMultimedia_PackedString filePathPacked = { const_cast<char*>(t7df503.prepend("WHITESPACE").constData()+10), t7df503.size()-10 };return callbackQCameraFeedbackControl_SetEventFeedbackSound(this, event, filePathPacked) != 0; };
 	void resetEventFeedback(QCameraFeedbackControl::EventType event) { callbackQCameraFeedbackControl_ResetEventFeedback(this, event); };
@@ -5647,7 +5647,7 @@ char QCameraFeedbackControl_IsEventFeedbackLocked(void* ptr, long long event)
 class MyQCameraFlashControl: public QCameraFlashControl
 {
 public:
-	MyQCameraFlashControl(QObject *parent) : QCameraFlashControl(parent) {};
+	MyQCameraFlashControl(QObject *parent = Q_NULLPTR) : QCameraFlashControl(parent) {};
 	void Signal_FlashReady(bool ready) { callbackQCameraFlashControl_FlashReady(this, ready); };
 	void setFlashMode(QCameraExposure::FlashModes mode) { callbackQCameraFlashControl_SetFlashMode(this, mode); };
 	QCameraExposure::FlashModes flashMode() const { return static_cast<QCameraExposure::FlashMode>(callbackQCameraFlashControl_FlashMode(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -6264,7 +6264,7 @@ char QCameraFocusZone_IsValid(void* ptr)
 class MyQCameraImageCapture: public QCameraImageCapture
 {
 public:
-	MyQCameraImageCapture(QMediaObject *mediaObject, QObject *parent) : QCameraImageCapture(mediaObject, parent) {};
+	MyQCameraImageCapture(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QCameraImageCapture(mediaObject, parent) {};
 	bool setMediaObject(QMediaObject * mediaObject) { return callbackQCameraImageCapture_SetMediaObject(this, mediaObject) != 0; };
 	int capture(const QString & file) { QByteArray t971c41 = file.toUtf8(); QtMultimedia_PackedString filePacked = { const_cast<char*>(t971c41.prepend("WHITESPACE").constData()+10), t971c41.size()-10 };return callbackQCameraImageCapture_Capture(this, filePacked); };
 	void Signal_BufferFormatChanged(QVideoFrame::PixelFormat format) { callbackQCameraImageCapture_BufferFormatChanged(this, format); };
@@ -6840,7 +6840,7 @@ void* QCameraImageCapture_MetaObjectDefault(void* ptr)
 class MyQCameraImageCaptureControl: public QCameraImageCaptureControl
 {
 public:
-	MyQCameraImageCaptureControl(QObject *parent) : QCameraImageCaptureControl(parent) {};
+	MyQCameraImageCaptureControl(QObject *parent = Q_NULLPTR) : QCameraImageCaptureControl(parent) {};
 	int capture(const QString & fileName) { QByteArray td83e09 = fileName.toUtf8(); QtMultimedia_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };return callbackQCameraImageCaptureControl_Capture(this, fileNamePacked); };
 	void cancelCapture() { callbackQCameraImageCaptureControl_CancelCapture(this); };
 	void Signal_Error(int id, int error, const QString & errorString) { QByteArray tc8b6bd = errorString.toUtf8(); QtMultimedia_PackedString errorStringPacked = { const_cast<char*>(tc8b6bd.prepend("WHITESPACE").constData()+10), tc8b6bd.size()-10 };callbackQCameraImageCaptureControl_Error(this, id, error, errorStringPacked); };
@@ -7346,7 +7346,7 @@ void* QCameraImageProcessing_MetaObjectDefault(void* ptr)
 class MyQCameraImageProcessingControl: public QCameraImageProcessingControl
 {
 public:
-	MyQCameraImageProcessingControl(QObject *parent) : QCameraImageProcessingControl(parent) {};
+	MyQCameraImageProcessingControl(QObject *parent = Q_NULLPTR) : QCameraImageProcessingControl(parent) {};
 	void setParameter(QCameraImageProcessingControl::ProcessingParameter parameter, const QVariant & value) { callbackQCameraImageProcessingControl_SetParameter(this, parameter, const_cast<QVariant*>(&value)); };
 	QVariant parameter(QCameraImageProcessingControl::ProcessingParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraImageProcessingControl_Parameter(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
 	bool isParameterSupported(QCameraImageProcessingControl::ProcessingParameter parameter) const { return callbackQCameraImageProcessingControl_IsParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
@@ -7503,7 +7503,7 @@ void* QCameraInfo___availableCameras_newList(void* ptr)
 class MyQCameraInfoControl: public QCameraInfoControl
 {
 public:
-	MyQCameraInfoControl(QObject *parent) : QCameraInfoControl(parent) {};
+	MyQCameraInfoControl(QObject *parent = Q_NULLPTR) : QCameraInfoControl(parent) {};
 	 ~MyQCameraInfoControl() { callbackQCameraInfoControl_DestroyQCameraInfoControl(this); };
 	QCamera::Position cameraPosition(const QString & deviceName) const { QByteArray t0f5a7b = deviceName.toUtf8(); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b.prepend("WHITESPACE").constData()+10), t0f5a7b.size()-10 };return static_cast<QCamera::Position>(callbackQCameraInfoControl_CameraPosition(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked)); };
 	int cameraOrientation(const QString & deviceName) const { QByteArray t0f5a7b = deviceName.toUtf8(); QtMultimedia_PackedString deviceNamePacked = { const_cast<char*>(t0f5a7b.prepend("WHITESPACE").constData()+10), t0f5a7b.size()-10 };return callbackQCameraInfoControl_CameraOrientation(const_cast<void*>(static_cast<const void*>(this)), deviceNamePacked); };
@@ -7584,7 +7584,7 @@ int QCameraInfoControl_CameraOrientation(void* ptr, char* deviceName)
 class MyQCameraLocksControl: public QCameraLocksControl
 {
 public:
-	MyQCameraLocksControl(QObject *parent) : QCameraLocksControl(parent) {};
+	MyQCameraLocksControl(QObject *parent = Q_NULLPTR) : QCameraLocksControl(parent) {};
 	void Signal_LockStatusChanged(QCamera::LockType lock, QCamera::LockStatus status, QCamera::LockChangeReason reason) { callbackQCameraLocksControl_LockStatusChanged(this, lock, status, reason); };
 	void searchAndLock(QCamera::LockTypes locks) { callbackQCameraLocksControl_SearchAndLock(this, locks); };
 	void unlock(QCamera::LockTypes locks) { callbackQCameraLocksControl_Unlock(this, locks); };
@@ -7687,7 +7687,7 @@ long long QCameraLocksControl_SupportedLocks(void* ptr)
 class MyQCameraViewfinder: public QCameraViewfinder
 {
 public:
-	MyQCameraViewfinder(QWidget *parent) : QCameraViewfinder(parent) {};
+	MyQCameraViewfinder(QWidget *parent = Q_NULLPTR) : QCameraViewfinder(parent) {};
 	bool setMediaObject(QMediaObject * object) { return callbackQCameraViewfinder_SetMediaObject(this, object) != 0; };
 	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQVideoWidget_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 	bool event(QEvent * event) { return callbackQVideoWidget_Event(this, event) != 0; };
@@ -7880,7 +7880,7 @@ double QCameraViewfinderSettings_MinimumFrameRate(void* ptr)
 class MyQCameraViewfinderSettingsControl: public QCameraViewfinderSettingsControl
 {
 public:
-	MyQCameraViewfinderSettingsControl(QObject *parent) : QCameraViewfinderSettingsControl(parent) {};
+	MyQCameraViewfinderSettingsControl(QObject *parent = Q_NULLPTR) : QCameraViewfinderSettingsControl(parent) {};
 	void setViewfinderParameter(QCameraViewfinderSettingsControl::ViewfinderParameter parameter, const QVariant & value) { callbackQCameraViewfinderSettingsControl_SetViewfinderParameter(this, parameter, const_cast<QVariant*>(&value)); };
 	QVariant viewfinderParameter(QCameraViewfinderSettingsControl::ViewfinderParameter parameter) const { return *static_cast<QVariant*>(callbackQCameraViewfinderSettingsControl_ViewfinderParameter(const_cast<void*>(static_cast<const void*>(this)), parameter)); };
 	bool isViewfinderParameterSupported(QCameraViewfinderSettingsControl::ViewfinderParameter parameter) const { return callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported(const_cast<void*>(static_cast<const void*>(this)), parameter) != 0; };
@@ -7961,7 +7961,7 @@ char QCameraViewfinderSettingsControl_IsViewfinderParameterSupported(void* ptr,
 class MyQCameraViewfinderSettingsControl2: public QCameraViewfinderSettingsControl2
 {
 public:
-	MyQCameraViewfinderSettingsControl2(QObject *parent) : QCameraViewfinderSettingsControl2(parent) {};
+	MyQCameraViewfinderSettingsControl2(QObject *parent = Q_NULLPTR) : QCameraViewfinderSettingsControl2(parent) {};
 	void setViewfinderSettings(const QCameraViewfinderSettings & settings) { callbackQCameraViewfinderSettingsControl2_SetViewfinderSettings(this, const_cast<QCameraViewfinderSettings*>(&settings)); };
 	 ~MyQCameraViewfinderSettingsControl2() { callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(this); };
 	QCameraViewfinderSettings viewfinderSettings() const { return *static_cast<QCameraViewfinderSettings*>(callbackQCameraViewfinderSettingsControl2_ViewfinderSettings(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -8063,7 +8063,7 @@ void* QCameraViewfinderSettingsControl2___supportedViewfinderSettings_newList(vo
 class MyQCameraZoomControl: public QCameraZoomControl
 {
 public:
-	MyQCameraZoomControl(QObject *parent) : QCameraZoomControl(parent) {};
+	MyQCameraZoomControl(QObject *parent = Q_NULLPTR) : QCameraZoomControl(parent) {};
 	void Signal_CurrentDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentDigitalZoomChanged(this, zoom); };
 	void Signal_CurrentOpticalZoomChanged(qreal zoom) { callbackQCameraZoomControl_CurrentOpticalZoomChanged(this, zoom); };
 	void Signal_MaximumDigitalZoomChanged(qreal zoom) { callbackQCameraZoomControl_MaximumDigitalZoomChanged(this, zoom); };
@@ -8264,7 +8264,7 @@ double QCameraZoomControl_RequestedOpticalZoom(void* ptr)
 class MyQGraphicsVideoItem: public QGraphicsVideoItem
 {
 public:
-	MyQGraphicsVideoItem(QGraphicsItem *parent) : QGraphicsVideoItem(parent) {};
+	MyQGraphicsVideoItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsVideoItem(parent) {};
 	void Signal_NativeSizeChanged(const QSizeF & size) { callbackQGraphicsVideoItem_NativeSizeChanged(this, const_cast<QSizeF*>(&size)); };
 	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsVideoItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
 	QMediaObject * mediaObject() const { return static_cast<QMediaObject*>(callbackQGraphicsVideoItem_MediaObject(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -9091,7 +9091,7 @@ char QGraphicsVideoItem_SetMediaObjectDefault(void* ptr, void* object)
 class MyQImageEncoderControl: public QImageEncoderControl
 {
 public:
-	MyQImageEncoderControl(QObject *parent) : QImageEncoderControl(parent) {};
+	MyQImageEncoderControl(QObject *parent = Q_NULLPTR) : QImageEncoderControl(parent) {};
 	void setImageSettings(const QImageEncoderSettings & settings) { callbackQImageEncoderControl_SetImageSettings(this, const_cast<QImageEncoderSettings*>(&settings)); };
 	 ~MyQImageEncoderControl() { callbackQImageEncoderControl_DestroyQImageEncoderControl(this); };
 	QImageEncoderSettings imageSettings() const { return *static_cast<QImageEncoderSettings*>(callbackQImageEncoderControl_ImageSettings(const_cast<void*>(static_cast<const void*>(this)))); };
@@ -9350,7 +9350,7 @@ void* QImageEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
 class MyQMediaAudioProbeControl: public QMediaAudioProbeControl
 {
 public:
-	MyQMediaAudioProbeControl(QObject *parent) : QMediaAudioProbeControl(parent) {};
+	MyQMediaAudioProbeControl(QObject *parent = Q_NULLPTR) : QMediaAudioProbeControl(parent) {};
 	void Signal_AudioBufferProbed(const QAudioBuffer & buffer) { callbackQMediaAudioProbeControl_AudioBufferProbed(this, const_cast<QAudioBuffer*>(&buffer)); };
 	void Signal_Flush() { callbackQMediaAudioProbeControl_Flush(this); };
 	 ~MyQMediaAudioProbeControl() { callbackQMediaAudioProbeControl_DestroyQMediaAudioProbeControl(this); };
@@ -9451,7 +9451,7 @@ void QMediaAudioProbeControl_DestroyQMediaAudioProbeControlDefault(void* ptr)
 class MyQMediaAvailabilityControl: public QMediaAvailabilityControl
 {
 public:
-	MyQMediaAvailabilityControl(QObject *parent) : QMediaAvailabilityControl(parent) {};
+	MyQMediaAvailabilityControl(QObject *parent = Q_NULLPTR) : QMediaAvailabilityControl(parent) {};
 	void Signal_AvailabilityChanged(QMultimedia::AvailabilityStatus availability) { callbackQMediaAvailabilityControl_AvailabilityChanged(this, availability); };
 	QMultimedia::AvailabilityStatus availability() const { return static_cast<QMultimedia::AvailabilityStatus>(callbackQMediaAvailabilityControl_Availability(const_cast<void*>(static_cast<const void*>(this)))); };
 	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
@@ -9592,7 +9592,7 @@ void* QMediaBindableInterface_MediaObject(void* ptr)
 class MyQMediaContainerControl: public QMediaContainerControl
 {
 public:
-	MyQMediaContainerControl(QObject *parent) : QMediaContainerControl(parent) {};
+	MyQMediaContainerControl(QObject *parent = Q_NULLPTR) : QMediaContainerControl(parent) {};
 	void setContainerFormat(const QString & format) { QByteArray t785987 = format.toUtf8(); QtMultimedia_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };callbackQMediaContainerControl_SetContainerFormat(this, formatPacked); };
 	 ~MyQMediaContainerControl() { callbackQMediaContainerControl_DestroyQMediaContainerControl(this); };
 	QString containerDescription(const QString & format) const { QByteArray t785987 = format.toUtf8(); QtMultimedia_PackedString formatPacked = { const_cast<char*>(t785987.prepend("WHITESPACE").constData()+10), t785987.size()-10 };return QString(callbackQMediaContainerControl_ContainerDescription(const_cast<void*>(static_cast<const void*>(this)), formatPacked)); };
@@ -9785,7 +9785,7 @@ void* QMediaContent___resources_newList(void* ptr)
 class MyQMediaControl: public QMediaControl
 {
 public:
-	MyQMediaControl(QObject *parent) : QMediaControl(parent) {};
+	MyQMediaControl(QObject *parent = Q_NULLPTR) : QMediaControl(parent) {};
 	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMediaControl_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQMediaControl_ChildEvent(this, event); };
@@ -11272,7 +11272,7 @@ void* QMediaControl_MetaObjectDefault(void* ptr)
 class MyQMediaGaplessPlaybackControl: public QMediaGaplessPlaybackControl
 {
 public:
-	MyQMediaGaplessPlaybackControl(QObject *parent) : QMediaGaplessPlaybackControl(parent) {};
+	MyQMediaGaplessPlaybackControl(QObject *parent = Q_NULLPTR) : QMediaGaplessPlaybackControl(parent) {};
 	void Signal_AdvancedToNextMedia() { callbackQMediaGaplessPlaybackControl_AdvancedToNextMedia(this); };
 	void Signal_CrossfadeTimeChanged(qreal crossfadeTime) { callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged(this, crossfadeTime); };
 	void Signal_NextMediaChanged(const QMediaContent & media) { callbackQMediaGaplessPlaybackControl_NextMediaChanged(this, const_cast<QMediaContent*>(&media)); };
@@ -12292,7 +12292,7 @@ void* QMediaObject_MetaObjectDefault(void* ptr)
 class MyQMediaPlayer: public QMediaPlayer
 {
 public:
-	MyQMediaPlayer(QObject *parent, Flags flags) : QMediaPlayer(parent, flags) {};
+	MyQMediaPlayer(QObject *parent = Q_NULLPTR, Flags flags = Flags()) : QMediaPlayer(parent, flags) {};
 	void Signal_AudioAvailableChanged(bool available) { callbackQMediaPlayer_AudioAvailableChanged(this, available); };
 	void Signal_AudioRoleChanged(QAudio::Role role) { callbackQMediaPlayer_AudioRoleChanged(this, role); };
 	void Signal_BufferStatusChanged(int percentFilled) { callbackQMediaPlayer_BufferStatusChanged(this, percentFilled); };
@@ -12887,7 +12887,7 @@ void* QMediaPlayer___supportedAudioRoles_newList(void* ptr)
 class MyQMediaPlayerControl: public QMediaPlayerControl
 {
 public:
-	MyQMediaPlayerControl(QObject *parent) : QMediaPlayerControl(parent) {};
+	MyQMediaPlayerControl(QObject *parent = Q_NULLPTR) : QMediaPlayerControl(parent) {};
 	void Signal_AudioAvailableChanged(bool audio) { callbackQMediaPlayerControl_AudioAvailableChanged(this, audio); };
 	void Signal_AvailablePlaybackRangesChanged(const QMediaTimeRange & ranges) { callbackQMediaPlayerControl_AvailablePlaybackRangesChanged(this, const_cast<QMediaTimeRange*>(&ranges)); };
 	void Signal_BufferStatusChanged(int progress) { callbackQMediaPlayerControl_BufferStatusChanged(this, progress); };
@@ -13306,7 +13306,7 @@ double QMediaPlayerControl_PlaybackRate(void* ptr)
 class MyQMediaPlaylist: public QMediaPlaylist
 {
 public:
-	MyQMediaPlaylist(QObject *parent) : QMediaPlaylist(parent) {};
+	MyQMediaPlaylist(QObject *parent = Q_NULLPTR) : QMediaPlaylist(parent) {};
 	void Signal_CurrentIndexChanged(int position) { callbackQMediaPlaylist_CurrentIndexChanged(this, position); };
 	void Signal_CurrentMediaChanged(const QMediaContent & content) { callbackQMediaPlaylist_CurrentMediaChanged(this, const_cast<QMediaContent*>(&content)); };
 	void Signal_LoadFailed() { callbackQMediaPlaylist_LoadFailed(this); };
@@ -13969,7 +13969,7 @@ char QMediaPlaylist_SetMediaObjectDefault(void* ptr, void* object)
 class MyQMediaRecorder: public QMediaRecorder
 {
 public:
-	MyQMediaRecorder(QMediaObject *mediaObject, QObject *parent) : QMediaRecorder(mediaObject, parent) {};
+	MyQMediaRecorder(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QMediaRecorder(mediaObject, parent) {};
 	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorder_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
 	void Signal_AvailabilityChanged2(QMultimedia::AvailabilityStatus availability) { callbackQMediaRecorder_AvailabilityChanged2(this, availability); };
 	void Signal_AvailabilityChanged(bool available) { callbackQMediaRecorder_AvailabilityChanged(this, available); };
@@ -14818,7 +14818,7 @@ char QMediaRecorder_SetMediaObjectDefault(void* ptr, void* object)
 class MyQMediaRecorderControl: public QMediaRecorderControl
 {
 public:
-	MyQMediaRecorderControl(QObject *parent) : QMediaRecorderControl(parent) {};
+	MyQMediaRecorderControl(QObject *parent = Q_NULLPTR) : QMediaRecorderControl(parent) {};
 	bool setOutputLocation(const QUrl & location) { return callbackQMediaRecorderControl_SetOutputLocation(this, const_cast<QUrl*>(&location)) != 0; };
 	void Signal_ActualLocationChanged(const QUrl & location) { callbackQMediaRecorderControl_ActualLocationChanged(this, const_cast<QUrl*>(&location)); };
 	void applySettings() { callbackQMediaRecorderControl_ApplySettings(this); };
@@ -15830,7 +15830,7 @@ struct QtMultimedia_PackedString QMediaServiceSupportedFormatsInterface_Supporte
 class MyQMediaStreamsControl: public QMediaStreamsControl
 {
 public:
-	MyQMediaStreamsControl(QObject *parent) : QMediaStreamsControl(parent) {};
+	MyQMediaStreamsControl(QObject *parent = Q_NULLPTR) : QMediaStreamsControl(parent) {};
 	QVariant metaData(int stream, const QString & key) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return *static_cast<QVariant*>(callbackQMediaStreamsControl_MetaData(this, stream, keyPacked)); };
 	StreamType streamType(int stream) { return static_cast<QMediaStreamsControl::StreamType>(callbackQMediaStreamsControl_StreamType(this, stream)); };
 	bool isActive(int stream) { return callbackQMediaStreamsControl_IsActive(this, stream) != 0; };
@@ -16111,7 +16111,7 @@ void* QMediaTimeRange___intervals_newList(void* ptr)
 class MyQMediaVideoProbeControl: public QMediaVideoProbeControl
 {
 public:
-	MyQMediaVideoProbeControl(QObject *parent) : QMediaVideoProbeControl(parent) {};
+	MyQMediaVideoProbeControl(QObject *parent = Q_NULLPTR) : QMediaVideoProbeControl(parent) {};
 	void Signal_Flush() { callbackQMediaVideoProbeControl_Flush(this); };
 	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQMediaVideoProbeControl_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
 	 ~MyQMediaVideoProbeControl() { callbackQMediaVideoProbeControl_DestroyQMediaVideoProbeControl(this); };
@@ -16212,7 +16212,7 @@ void QMediaVideoProbeControl_DestroyQMediaVideoProbeControlDefault(void* ptr)
 class MyQMetaDataReaderControl: public QMetaDataReaderControl
 {
 public:
-	MyQMetaDataReaderControl(QObject *parent) : QMetaDataReaderControl(parent) {};
+	MyQMetaDataReaderControl(QObject *parent = Q_NULLPTR) : QMetaDataReaderControl(parent) {};
 	void Signal_MetaDataAvailableChanged(bool available) { callbackQMetaDataReaderControl_MetaDataAvailableChanged(this, available); };
 	void Signal_MetaDataChanged() { callbackQMetaDataReaderControl_MetaDataChanged(this); };
 	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMetaDataReaderControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
@@ -16341,7 +16341,7 @@ char QMetaDataReaderControl_IsMetaDataAvailable(void* ptr)
 class MyQMetaDataWriterControl: public QMetaDataWriterControl
 {
 public:
-	MyQMetaDataWriterControl(QObject *parent) : QMetaDataWriterControl(parent) {};
+	MyQMetaDataWriterControl(QObject *parent = Q_NULLPTR) : QMetaDataWriterControl(parent) {};
 	void Signal_MetaDataAvailableChanged(bool available) { callbackQMetaDataWriterControl_MetaDataAvailableChanged(this, available); };
 	void Signal_MetaDataChanged() { callbackQMetaDataWriterControl_MetaDataChanged(this); };
 	void Signal_MetaDataChanged2(const QString & key, const QVariant & value) { QByteArray ta62f22 = key.toUtf8(); QtMultimedia_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQMetaDataWriterControl_MetaDataChanged2(this, keyPacked, const_cast<QVariant*>(&value)); };
@@ -16498,7 +16498,7 @@ char QMetaDataWriterControl_IsWritable(void* ptr)
 class MyQRadioData: public QRadioData
 {
 public:
-	MyQRadioData(QMediaObject *mediaObject, QObject *parent) : QRadioData(mediaObject, parent) {};
+	MyQRadioData(QMediaObject *mediaObject, QObject *parent = Q_NULLPTR) : QRadioData(mediaObject, parent) {};
 	void setAlternativeFrequenciesEnabled(bool enabled) { callbackQRadioData_SetAlternativeFrequenciesEnabled(this, enabled); };
 	bool setMediaObject(QMediaObject * mediaObject) { return callbackQRadioData_SetMediaObject(this, mediaObject) != 0; };
 	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioData_AlternativeFrequenciesEnabledChanged(this, enabled); };
@@ -16964,7 +16964,7 @@ void* QRadioData_MetaObjectDefault(void* ptr)
 class MyQRadioDataControl: public QRadioDataControl
 {
 public:
-	MyQRadioDataControl(QObject *parent) : QRadioDataControl(parent) {};
+	MyQRadioDataControl(QObject *parent = Q_NULLPTR) : QRadioDataControl(parent) {};
 	void Signal_AlternativeFrequenciesEnabledChanged(bool enabled) { callbackQRadioDataControl_AlternativeFrequenciesEnabledChanged(this, enabled); };
 	void Signal_Error2(QRadioData::Error error) { callbackQRadioDataControl_Error2(this, error); };
 	void Signal_ProgramTypeChanged(QRadioData::ProgramType programType) { callbackQRadioDataControl_ProgramTypeChanged(this, programType); };
@@ -17193,7 +17193,7 @@ char QRadioDataControl_IsAlternativeFrequenciesEnabled(void* ptr)
 class MyQRadioTuner: public QRadioTuner
 {
 public:
-	MyQRadioTuner(QObject *parent) : QRadioTuner(parent) {};
+	MyQRadioTuner(QObject *parent = Q_NULLPTR) : QRadioTuner(parent) {};
 	void Signal_AntennaConnectedChanged(bool connectionStatus) { callbackQRadioTuner_AntennaConnectedChanged(this, connectionStatus); };
 	void Signal_BandChanged(QRadioTuner::Band band) { callbackQRadioTuner_BandChanged(this, band); };
 	void cancelSearch() { callbackQRadioTuner_CancelSearch(this); };
@@ -17985,7 +17985,7 @@ int QRadioTunerControl_Volume(void* ptr)
 class MyQSound: public QSound
 {
 public:
-	MyQSound(const QString &filename, QObject *parent) : QSound(filename, parent) {};
+	MyQSound(const QString &filename, QObject *parent = Q_NULLPTR) : QSound(filename, parent) {};
 	void play() { callbackQSound_Play2(this); };
 	void stop() { callbackQSound_Stop(this); };
 	bool event(QEvent * e) { return callbackQSound_Event(this, e) != 0; };
@@ -18290,7 +18290,7 @@ void* QSound_MetaObjectDefault(void* ptr)
 class MyQSoundEffect: public QSoundEffect
 {
 public:
-	MyQSoundEffect(QObject *parent) : QSoundEffect(parent) {};
+	MyQSoundEffect(QObject *parent = Q_NULLPTR) : QSoundEffect(parent) {};
 	void Signal_CategoryChanged() { callbackQSoundEffect_CategoryChanged(this); };
 	void Signal_LoadedChanged() { callbackQSoundEffect_LoadedChanged(this); };
 	void Signal_LoopCountChanged() { callbackQSoundEffect_LoopCountChanged(this); };
@@ -18784,7 +18784,7 @@ void* QSoundEffect_MetaObjectDefault(void* ptr)
 class MyQVideoDeviceSelectorControl: public QVideoDeviceSelectorControl
 {
 public:
-	MyQVideoDeviceSelectorControl(QObject *parent) : QVideoDeviceSelectorControl(parent) {};
+	MyQVideoDeviceSelectorControl(QObject *parent = Q_NULLPTR) : QVideoDeviceSelectorControl(parent) {};
 	void Signal_DevicesChanged() { callbackQVideoDeviceSelectorControl_DevicesChanged(this); };
 	void Signal_SelectedDeviceChanged2(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtMultimedia_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2(this, namePacked); };
 	void Signal_SelectedDeviceChanged(int index) { callbackQVideoDeviceSelectorControl_SelectedDeviceChanged(this, index); };
@@ -19112,7 +19112,7 @@ void* QVideoEncoderSettings_____encodingOptions_keyList_newList(void* ptr)
 class MyQVideoEncoderSettingsControl: public QVideoEncoderSettingsControl
 {
 public:
-	MyQVideoEncoderSettingsControl(QObject *parent) : QVideoEncoderSettingsControl(parent) {};
+	MyQVideoEncoderSettingsControl(QObject *parent = Q_NULLPTR) : QVideoEncoderSettingsControl(parent) {};
 	void setVideoSettings(const QVideoEncoderSettings & settings) { callbackQVideoEncoderSettingsControl_SetVideoSettings(this, const_cast<QVideoEncoderSettings*>(&settings)); };
 	 ~MyQVideoEncoderSettingsControl() { callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(this); };
 	QList<QSize> supportedResolutions(const QVideoEncoderSettings & settings, bool * continuous) const { return *static_cast<QList<QSize>*>(callbackQVideoEncoderSettingsControl_SupportedResolutions(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVideoEncoderSettings*>(&settings), *continuous)); };
@@ -19483,7 +19483,7 @@ void* QVideoFrame_____availableMetaData_keyList_newList(void* ptr)
 class MyQVideoProbe: public QVideoProbe
 {
 public:
-	MyQVideoProbe(QObject *parent) : QVideoProbe(parent) {};
+	MyQVideoProbe(QObject *parent = Q_NULLPTR) : QVideoProbe(parent) {};
 	void Signal_Flush() { callbackQVideoProbe_Flush(this); };
 	void Signal_VideoFrameProbed(const QVideoFrame & frame) { callbackQVideoProbe_VideoFrameProbed(this, const_cast<QVideoFrame*>(&frame)); };
 	bool event(QEvent * e) { return callbackQVideoProbe_Event(this, e) != 0; };
@@ -19783,7 +19783,7 @@ void* QVideoProbe_MetaObjectDefault(void* ptr)
 class MyQVideoRendererControl: public QVideoRendererControl
 {
 public:
-	MyQVideoRendererControl(QObject *parent) : QVideoRendererControl(parent) {};
+	MyQVideoRendererControl(QObject *parent = Q_NULLPTR) : QVideoRendererControl(parent) {};
 	void setSurface(QAbstractVideoSurface * surface) { callbackQVideoRendererControl_SetSurface(this, surface); };
 	QAbstractVideoSurface * surface() const { return static_cast<QAbstractVideoSurface*>(callbackQVideoRendererControl_Surface(const_cast<void*>(static_cast<const void*>(this)))); };
 	bool event(QEvent * e) { return callbackQMediaControl_Event(this, e) != 0; };
@@ -20008,7 +20008,7 @@ void* QVideoSurfaceFormat___propertyNames_newList(void* ptr)
 class MyQVideoWidget: public QVideoWidget
 {
 public:
-	MyQVideoWidget(QWidget *parent) : QVideoWidget(parent) {};
+	MyQVideoWidget(QWidget *parent = Q_NULLPTR) : QVideoWidget(parent) {};
 	bool event(QEvent * event) { return callbackQVideoWidget_Event(this, event) != 0; };
 	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidget_BrightnessChanged(this, brightness); };
 	void Signal_ContrastChanged(int contrast) { callbackQVideoWidget_ContrastChanged(this, contrast); };
@@ -21439,7 +21439,7 @@ char QVideoWidget_SetMediaObjectDefault(void* ptr, void* object)
 class MyQVideoWidgetControl: public QVideoWidgetControl
 {
 public:
-	MyQVideoWidgetControl(QObject *parent) : QVideoWidgetControl(parent) {};
+	MyQVideoWidgetControl(QObject *parent = Q_NULLPTR) : QVideoWidgetControl(parent) {};
 	QWidget * videoWidget() { return static_cast<QWidget*>(callbackQVideoWidgetControl_VideoWidget(this)); };
 	void Signal_BrightnessChanged(int brightness) { callbackQVideoWidgetControl_BrightnessChanged(this, brightness); };
 	void Signal_ContrastChanged(int contrast) { callbackQVideoWidgetControl_ContrastChanged(this, contrast); };
@@ -21666,7 +21666,7 @@ int QVideoWidgetControl_Saturation(void* ptr)
 class MyQVideoWindowControl: public QVideoWindowControl
 {
 public:
-	MyQVideoWindowControl(QObject *parent) : QVideoWindowControl(parent) {};
+	MyQVideoWindowControl(QObject *parent = Q_NULLPTR) : QVideoWindowControl(parent) {};
 	void Signal_BrightnessChanged(int brightness) { callbackQVideoWindowControl_BrightnessChanged(this, brightness); };
 	void Signal_ContrastChanged(int contrast) { callbackQVideoWindowControl_ContrastChanged(this, contrast); };
 	void Signal_FullScreenChanged(bool fullScreen) { callbackQVideoWindowControl_FullScreenChanged(this, fullScreen); };

network/network.cpp

@@ -96,7 +96,7 @@
 class MyQAbstractNetworkCache: public QAbstractNetworkCache
 {
 public:
-	MyQAbstractNetworkCache(QObject *parent) : QAbstractNetworkCache(parent) {};
+	MyQAbstractNetworkCache(QObject *parent = Q_NULLPTR) : QAbstractNetworkCache(parent) {};
 	QIODevice * data(const QUrl & url) { return static_cast<QIODevice*>(callbackQAbstractNetworkCache_Data(this, const_cast<QUrl*>(&url))); };
 	QIODevice * prepare(const QNetworkCacheMetaData & metaData) { return static_cast<QIODevice*>(callbackQAbstractNetworkCache_Prepare(this, const_cast<QNetworkCacheMetaData*>(&metaData))); };
 	QNetworkCacheMetaData metaData(const QUrl & url) { return *static_cast<QNetworkCacheMetaData*>(callbackQAbstractNetworkCache_MetaData(this, const_cast<QUrl*>(&url))); };
@@ -1427,9 +1427,9 @@ unsigned int QDnsHostAddressRecord_TimeToLive(void* ptr)
 class MyQDnsLookup: public QDnsLookup
 {
 public:
-	MyQDnsLookup(QObject *parent) : QDnsLookup(parent) {};
+	MyQDnsLookup(QObject *parent = Q_NULLPTR) : QDnsLookup(parent) {};
-	MyQDnsLookup(Type type, const QString &name, QObject *parent) : QDnsLookup(type, name, parent) {};
+	MyQDnsLookup(Type type, const QString &name, QObject *parent = Q_NULLPTR) : QDnsLookup(type, name, parent) {};
-	MyQDnsLookup(Type type, const QString &name, const QHostAddress &nameserver, QObject *parent) : QDnsLookup(type, name, nameserver, parent) {};
+	MyQDnsLookup(Type type, const QString &name, const QHostAddress &nameserver, QObject *parent = Q_NULLPTR) : QDnsLookup(type, name, nameserver, parent) {};
 	void abort() { callbackQDnsLookup_Abort(this); };
 	void Signal_Finished() { callbackQDnsLookup_Finished(this); };
 	void lookup() { callbackQDnsLookup_Lookup(this); };
@@ -2355,8 +2355,8 @@ void* QHostInfo___addresses_newList(void* ptr)
 class MyQHttpMultiPart: public QHttpMultiPart
 {
 public:
-	MyQHttpMultiPart(ContentType contentType, QObject *parent) : QHttpMultiPart(contentType, parent) {};
+	MyQHttpMultiPart(ContentType contentType, QObject *parent = Q_NULLPTR) : QHttpMultiPart(contentType, parent) {};
-	MyQHttpMultiPart(QObject *parent) : QHttpMultiPart(parent) {};
+	MyQHttpMultiPart(QObject *parent = Q_NULLPTR) : QHttpMultiPart(parent) {};
 	bool event(QEvent * e) { return callbackQHttpMultiPart_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQHttpMultiPart_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQHttpMultiPart_ChildEvent(this, event); };
@@ -2640,7 +2640,7 @@ void QHttpPart_DestroyQHttpPart(void* ptr)
 class MyQLocalServer: public QLocalServer
 {
 public:
-	MyQLocalServer(QObject *parent) : QLocalServer(parent) {};
+	MyQLocalServer(QObject *parent = Q_NULLPTR) : QLocalServer(parent) {};
 	QLocalSocket * nextPendingConnection() { return static_cast<QLocalSocket*>(callbackQLocalServer_NextPendingConnection(this)); };
 	void incomingConnection(quintptr socketDescriptor) { callbackQLocalServer_IncomingConnection(this, socketDescriptor); };
 	void Signal_NewConnection() { callbackQLocalServer_NewConnection(this); };
@@ -2937,7 +2937,7 @@ void* QLocalServer_MetaObjectDefault(void* ptr)
 class MyQLocalSocket: public QLocalSocket
 {
 public:
-	MyQLocalSocket(QObject *parent) : QLocalSocket(parent) {};
+	MyQLocalSocket(QObject *parent = Q_NULLPTR) : QLocalSocket(parent) {};
 	bool open(QIODevice::OpenMode openMode) { return callbackQLocalSocket_Open(this, openMode) != 0; };
 	bool waitForBytesWritten(int msecs) { return callbackQLocalSocket_WaitForBytesWritten(this, msecs) != 0; };
 	bool waitForReadyRead(int msecs) { return callbackQLocalSocket_WaitForReadyRead(this, msecs) != 0; };
@@ -3371,7 +3371,7 @@ void* QLocalSocket_MetaObjectDefault(void* ptr)
 class MyQNetworkAccessManager: public QNetworkAccessManager
 {
 public:
-	MyQNetworkAccessManager(QObject *parent) : QNetworkAccessManager(parent) {};
+	MyQNetworkAccessManager(QObject *parent = Q_NULLPTR) : QNetworkAccessManager(parent) {};
 	QNetworkReply * createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest & req, QIODevice * outgoingData) { return static_cast<QNetworkReply*>(callbackQNetworkAccessManager_CreateRequest(this, op, const_cast<QNetworkRequest*>(&req), outgoingData)); };
 	void Signal_AuthenticationRequired(QNetworkReply * reply, QAuthenticator * authenticator) { callbackQNetworkAccessManager_AuthenticationRequired(this, reply, authenticator); };
 	void Signal_Encrypted(QNetworkReply * reply) { callbackQNetworkAccessManager_Encrypted(this, reply); };
@@ -4065,7 +4065,7 @@ void* QNetworkConfiguration___children_newList(void* ptr)
 class MyQNetworkConfigurationManager: public QNetworkConfigurationManager
 {
 public:
-	MyQNetworkConfigurationManager(QObject *parent) : QNetworkConfigurationManager(parent) {};
+	MyQNetworkConfigurationManager(QObject *parent = Q_NULLPTR) : QNetworkConfigurationManager(parent) {};
 	void Signal_ConfigurationAdded(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManager_ConfigurationAdded(this, const_cast<QNetworkConfiguration*>(&config)); };
 	void Signal_ConfigurationChanged(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManager_ConfigurationChanged(this, const_cast<QNetworkConfiguration*>(&config)); };
 	void Signal_ConfigurationRemoved(const QNetworkConfiguration & config) { callbackQNetworkConfigurationManager_ConfigurationRemoved(this, const_cast<QNetworkConfiguration*>(&config)); };
@@ -4515,7 +4515,7 @@ void* QNetworkCookie___parseCookies_newList(void* ptr)
 class MyQNetworkCookieJar: public QNetworkCookieJar
 {
 public:
-	MyQNetworkCookieJar(QObject *parent) : QNetworkCookieJar(parent) {};
+	MyQNetworkCookieJar(QObject *parent = Q_NULLPTR) : QNetworkCookieJar(parent) {};
 	bool deleteCookie(const QNetworkCookie & cookie) { return callbackQNetworkCookieJar_DeleteCookie(this, const_cast<QNetworkCookie*>(&cookie)) != 0; };
 	bool insertCookie(const QNetworkCookie & cookie) { return callbackQNetworkCookieJar_InsertCookie(this, const_cast<QNetworkCookie*>(&cookie)) != 0; };
 	bool setCookiesFromUrl(const QList<QNetworkCookie> & cookieList, const QUrl & url) { return callbackQNetworkCookieJar_SetCookiesFromUrl(this, ({ QList<QNetworkCookie>* tmpValue = const_cast<QList<QNetworkCookie>*>(&cookieList); QtNetwork_PackedList { tmpValue, tmpValue->size() }; }), const_cast<QUrl*>(&url)) != 0; };
@@ -4950,7 +4950,7 @@ unsigned int QNetworkDatagram_InterfaceIndex(void* ptr)
 class MyQNetworkDiskCache: public QNetworkDiskCache
 {
 public:
-	MyQNetworkDiskCache(QObject *parent) : QNetworkDiskCache(parent) {};
+	MyQNetworkDiskCache(QObject *parent = Q_NULLPTR) : QNetworkDiskCache(parent) {};
 	QIODevice * data(const QUrl & url) { return static_cast<QIODevice*>(callbackQNetworkDiskCache_Data(this, const_cast<QUrl*>(&url))); };
 	QIODevice * prepare(const QNetworkCacheMetaData & metaData) { return static_cast<QIODevice*>(callbackQNetworkDiskCache_Prepare(this, const_cast<QNetworkCacheMetaData*>(&metaData))); };
 	QNetworkCacheMetaData metaData(const QUrl & url) { return *static_cast<QNetworkCacheMetaData*>(callbackQNetworkDiskCache_MetaData(this, const_cast<QUrl*>(&url))); };
@@ -5635,7 +5635,7 @@ int QNetworkProxyQuery_PeerPort(void* ptr)
 class MyQNetworkReply: public QNetworkReply
 {
 public:
-	MyQNetworkReply(QObject *parent) : QNetworkReply(parent) {};
+	MyQNetworkReply(QObject *parent = Q_NULLPTR) : QNetworkReply(parent) {};
 	void abort() { callbackQNetworkReply_Abort(this); };
 	void close() { callbackQNetworkReply_Close(this); };
 	void Signal_DownloadProgress(qint64 bytesReceived, qint64 bytesTotal) { callbackQNetworkReply_DownloadProgress(this, bytesReceived, bytesTotal); };
@@ -6440,7 +6440,7 @@ void* QNetworkRequest___rawHeaderList_newList(void* ptr)
 class MyQNetworkSession: public QNetworkSession
 {
 public:
-	MyQNetworkSession(const QNetworkConfiguration &connectionConfig, QObject *parent) : QNetworkSession(connectionConfig, parent) {};
+	MyQNetworkSession(const QNetworkConfiguration &connectionConfig, QObject *parent = Q_NULLPTR) : QNetworkSession(connectionConfig, parent) {};
 	void accept() { callbackQNetworkSession_Accept(this); };
 	void close() { callbackQNetworkSession_Close(this); };
 	void Signal_Closed() { callbackQNetworkSession_Closed(this); };
@@ -8078,7 +8078,7 @@ int QSslPreSharedKeyAuthenticator_MaximumPreSharedKeyLength(void* ptr)
 class MyQSslSocket: public QSslSocket
 {
 public:
-	MyQSslSocket(QObject *parent) : QSslSocket(parent) {};
+	MyQSslSocket(QObject *parent = Q_NULLPTR) : QSslSocket(parent) {};
 	QVariant socketOption(QAbstractSocket::SocketOption option) { return *static_cast<QVariant*>(callbackQAbstractSocket_SocketOption(this, option)); };
 	bool waitForBytesWritten(int msecs) { return callbackQAbstractSocket_WaitForBytesWritten(this, msecs) != 0; };
 	bool waitForConnected(int msecs) { return callbackQAbstractSocket_WaitForConnected(this, msecs) != 0; };
@@ -8787,7 +8787,7 @@ void* QSslSocket___sslErrors_newList(void* ptr)
 class MyQTcpServer: public QTcpServer
 {
 public:
-	MyQTcpServer(QObject *parent) : QTcpServer(parent) {};
+	MyQTcpServer(QObject *parent = Q_NULLPTR) : QTcpServer(parent) {};
 	QTcpSocket * nextPendingConnection() { return static_cast<QTcpSocket*>(callbackQTcpServer_NextPendingConnection(this)); };
 	void Signal_AcceptError(QAbstractSocket::SocketError socketError) { callbackQTcpServer_AcceptError(this, socketError); };
 	void Signal_NewConnection() { callbackQTcpServer_NewConnection(this); };
@@ -9105,7 +9105,7 @@ void* QTcpServer_MetaObjectDefault(void* ptr)
 class MyQTcpSocket: public QTcpSocket
 {
 public:
-	MyQTcpSocket(QObject *parent) : QTcpSocket(parent) {};
+	MyQTcpSocket(QObject *parent = Q_NULLPTR) : QTcpSocket(parent) {};
 	 ~MyQTcpSocket() { callbackQTcpSocket_DestroyQTcpSocket(this); };
 	QVariant socketOption(QAbstractSocket::SocketOption option) { return *static_cast<QVariant*>(callbackQAbstractSocket_SocketOption(this, option)); };
 	bool waitForBytesWritten(int msecs) { return callbackQAbstractSocket_WaitForBytesWritten(this, msecs) != 0; };
@@ -9211,7 +9211,7 @@ void QTcpSocket_DestroyQTcpSocketDefault(void* ptr)
 class MyQUdpSocket: public QUdpSocket
 {
 public:
-	MyQUdpSocket(QObject *parent) : QUdpSocket(parent) {};
+	MyQUdpSocket(QObject *parent = Q_NULLPTR) : QUdpSocket(parent) {};
 	 ~MyQUdpSocket() { callbackQUdpSocket_DestroyQUdpSocket(this); };
 	QVariant socketOption(QAbstractSocket::SocketOption option) { return *static_cast<QVariant*>(callbackQAbstractSocket_SocketOption(this, option)); };
 	bool waitForBytesWritten(int msecs) { return callbackQAbstractSocket_WaitForBytesWritten(this, msecs) != 0; };

nfc/nfc.cpp

@@ -605,7 +605,7 @@ char QNdefRecord_IsEmpty(void* ptr)
 class MyQNearFieldManager: public QNearFieldManager
 {
 public:
-	MyQNearFieldManager(QObject *parent) : QNearFieldManager(parent) {};
+	MyQNearFieldManager(QObject *parent = Q_NULLPTR) : QNearFieldManager(parent) {};
 	void Signal_TargetDetected(QNearFieldTarget * target) { callbackQNearFieldManager_TargetDetected(this, target); };
 	void Signal_TargetLost(QNearFieldTarget * target) { callbackQNearFieldManager_TargetLost(this, target); };
 	bool event(QEvent * e) { return callbackQNearFieldManager_Event(this, e) != 0; };
@@ -865,7 +865,7 @@ void* QNearFieldManager_MetaObjectDefault(void* ptr)
 class MyQNearFieldShareManager: public QNearFieldShareManager
 {
 public:
-	MyQNearFieldShareManager(QObject *parent) : QNearFieldShareManager(parent) {};
+	MyQNearFieldShareManager(QObject *parent = Q_NULLPTR) : QNearFieldShareManager(parent) {};
 	void Signal_Error(QNearFieldShareManager::ShareError error) { callbackQNearFieldShareManager_Error(this, error); };
 	void Signal_ShareModesChanged(QNearFieldShareManager::ShareModes modes) { callbackQNearFieldShareManager_ShareModesChanged(this, modes); };
 	void Signal_TargetDetected(QNearFieldShareTarget * shareTarget) { callbackQNearFieldShareManager_TargetDetected(this, shareTarget); };
@@ -1334,7 +1334,7 @@ void* QNearFieldShareTarget_MetaObjectDefault(void* ptr)
 class MyQNearFieldTarget: public QNearFieldTarget
 {
 public:
-	MyQNearFieldTarget(QObject *parent) : QNearFieldTarget(parent) {};
+	MyQNearFieldTarget(QObject *parent = Q_NULLPTR) : QNearFieldTarget(parent) {};
 	bool hasNdefMessage() { return callbackQNearFieldTarget_HasNdefMessage(this) != 0; };
 	void Signal_Disconnected() { callbackQNearFieldTarget_Disconnected(this); };
 	void Signal_NdefMessageRead(const QNdefMessage & message) { callbackQNearFieldTarget_NdefMessageRead(this, const_cast<QNdefMessage*>(&message)); };
@@ -1646,8 +1646,8 @@ void* QNearFieldTarget_MetaObjectDefault(void* ptr)
 class MyQQmlNdefRecord: public QQmlNdefRecord
 {
 public:
-	MyQQmlNdefRecord(QObject *parent) : QQmlNdefRecord(parent) {};
+	MyQQmlNdefRecord(QObject *parent = Q_NULLPTR) : QQmlNdefRecord(parent) {};
-	MyQQmlNdefRecord(const QNdefRecord &record, QObject *parent) : QQmlNdefRecord(record, parent) {};
+	MyQQmlNdefRecord(const QNdefRecord &record, QObject *parent = Q_NULLPTR) : QQmlNdefRecord(record, parent) {};
 	void Signal_RecordChanged() { callbackQQmlNdefRecord_RecordChanged(this); };
 	void Signal_TypeChanged() { callbackQQmlNdefRecord_TypeChanged(this); };
 	void Signal_TypeNameFormatChanged() { callbackQQmlNdefRecord_TypeNameFormatChanged(this); };

positioning/positioning.cpp

@@ -1904,7 +1904,7 @@ char QGeoShape_IsValid(void* ptr)
 class MyQNmeaPositionInfoSource: public QNmeaPositionInfoSource
 {
 public:
-	MyQNmeaPositionInfoSource(UpdateMode updateMode, QObject *parent) : QNmeaPositionInfoSource(updateMode, parent) {};
+	MyQNmeaPositionInfoSource(UpdateMode updateMode, QObject *parent = Q_NULLPTR) : QNmeaPositionInfoSource(updateMode, parent) {};
 	bool parsePosInfoFromNmeaData(const char * data, int size, QGeoPositionInfo * posInfo, bool * hasFix) { QtPositioning_PackedString dataPacked = { const_cast<char*>(data), size };return callbackQNmeaPositionInfoSource_ParsePosInfoFromNmeaData(this, dataPacked, size, posInfo, *hasFix) != 0; };
 	void requestUpdate(int msec) { callbackQNmeaPositionInfoSource_RequestUpdate(this, msec); };
 	void setUpdateInterval(int msec) { callbackQGeoPositionInfoSource_SetUpdateInterval(this, msec); };

printsupport/printsupport.cpp

@@ -62,7 +62,7 @@
 class MyQAbstractPrintDialog: public QAbstractPrintDialog
 {
 public:
-	MyQAbstractPrintDialog(QPrinter *printer, QWidget *parent) : QAbstractPrintDialog(printer, parent) {};
+	MyQAbstractPrintDialog(QPrinter *printer, QWidget *parent = Q_NULLPTR) : QAbstractPrintDialog(printer, parent) {};
 	int exec() { return callbackQAbstractPrintDialog_Exec(this); };
 	void accept() { callbackQAbstractPrintDialog_Accept(this); };
 	void Signal_Accepted() { callbackQAbstractPrintDialog_Accepted(this); };
@@ -952,8 +952,8 @@ void* QAbstractPrintDialog_MetaObjectDefault(void* ptr)
 class MyQPageSetupDialog: public QPageSetupDialog
 {
 public:
-	MyQPageSetupDialog(QPrinter *printer, QWidget *parent) : QPageSetupDialog(printer, parent) {};
+	MyQPageSetupDialog(QPrinter *printer, QWidget *parent = Q_NULLPTR) : QPageSetupDialog(printer, parent) {};
-	MyQPageSetupDialog(QWidget *parent) : QPageSetupDialog(parent) {};
+	MyQPageSetupDialog(QWidget *parent = Q_NULLPTR) : QPageSetupDialog(parent) {};
 	int exec() { return callbackQPageSetupDialog_Exec(this); };
 	void done(int result) { callbackQPageSetupDialog_Done(this, result); };
 	void setVisible(bool visible) { callbackQPageSetupDialog_SetVisible(this, visible); };
@@ -1528,8 +1528,8 @@ void* QPageSetupDialog_MetaObjectDefault(void* ptr)
 class MyQPrintDialog: public QPrintDialog
 {
 public:
-	MyQPrintDialog(QPrinter *printer, QWidget *parent) : QPrintDialog(printer, parent) {};
+	MyQPrintDialog(QPrinter *printer, QWidget *parent = Q_NULLPTR) : QPrintDialog(printer, parent) {};
-	MyQPrintDialog(QWidget *parent) : QPrintDialog(parent) {};
+	MyQPrintDialog(QWidget *parent = Q_NULLPTR) : QPrintDialog(parent) {};
 	void done(int result) { callbackQPrintDialog_Done(this, result); };
 	int exec() { return callbackQPrintDialog_Exec(this); };
 	void Signal_Accepted(QPrinter * printer) { callbackQPrintDialog_Accepted(this, printer); };
@@ -1739,8 +1739,8 @@ int QPrintEngine_Metric(void* ptr, long long id)
 class MyQPrintPreviewDialog: public QPrintPreviewDialog
 {
 public:
-	MyQPrintPreviewDialog(QPrinter *printer, QWidget *parent, Qt::WindowFlags flags) : QPrintPreviewDialog(printer, parent, flags) {};
+	MyQPrintPreviewDialog(QPrinter *printer, QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QPrintPreviewDialog(printer, parent, flags) {};
-	MyQPrintPreviewDialog(QWidget *parent, Qt::WindowFlags flags) : QPrintPreviewDialog(parent, flags) {};
+	MyQPrintPreviewDialog(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QPrintPreviewDialog(parent, flags) {};
 	void done(int result) { callbackQPrintPreviewDialog_Done(this, result); };
 	void Signal_PaintRequested(QPrinter * printer) { callbackQPrintPreviewDialog_PaintRequested(this, printer); };
 	void setVisible(bool visible) { callbackQPrintPreviewDialog_SetVisible(this, visible); };
@@ -2326,8 +2326,8 @@ void* QPrintPreviewDialog_MetaObjectDefault(void* ptr)
 class MyQPrintPreviewWidget: public QPrintPreviewWidget
 {
 public:
-	MyQPrintPreviewWidget(QPrinter *printer, QWidget *parent, Qt::WindowFlags flags) : QPrintPreviewWidget(printer, parent, flags) {};
+	MyQPrintPreviewWidget(QPrinter *printer, QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QPrintPreviewWidget(printer, parent, flags) {};
-	MyQPrintPreviewWidget(QWidget *parent, Qt::WindowFlags flags) : QPrintPreviewWidget(parent, flags) {};
+	MyQPrintPreviewWidget(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = Qt::WindowFlags()) : QPrintPreviewWidget(parent, flags) {};
 	void fitInView() { callbackQPrintPreviewWidget_FitInView(this); };
 	void fitToWidth() { callbackQPrintPreviewWidget_FitToWidth(this); };
 	void Signal_PaintRequested(QPrinter * printer) { callbackQPrintPreviewWidget_PaintRequested(this, printer); };
@@ -3100,8 +3100,8 @@ void* QPrintPreviewWidget_MetaObjectDefault(void* ptr)
 class MyQPrinter: public QPrinter
 {
 public:
-	MyQPrinter(PrinterMode mode) : QPrinter(mode) {};
+	MyQPrinter(PrinterMode mode = ScreenResolution) : QPrinter(mode) {};
-	MyQPrinter(const QPrinterInfo &printer, PrinterMode mode) : QPrinter(printer, mode) {};
+	MyQPrinter(const QPrinterInfo &printer, PrinterMode mode = ScreenResolution) : QPrinter(printer, mode) {};
 	bool newPage() { return callbackQPrinter_NewPage(this) != 0; };
 	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPrinter_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
 	void setPageSize(QPagedPaintDevice::PageSize size) { callbackQPrinter_SetPageSize2(this, size); };

purchasing/purchasing.cpp

@@ -213,7 +213,7 @@ void* QInAppProduct_MetaObjectDefault(void* ptr)
 class MyQInAppStore: public QInAppStore
 {
 public:
-	MyQInAppStore(QObject *parent) : QInAppStore(parent) {};
+	MyQInAppStore(QObject *parent = Q_NULLPTR) : QInAppStore(parent) {};
 	void Signal_ProductRegistered(QInAppProduct * product) { callbackQInAppStore_ProductRegistered(this, product); };
 	void Signal_ProductUnknown(QInAppProduct::ProductType productType, const QString & identifier) { QByteArray tfae9fd = identifier.toUtf8(); QtPurchasing_PackedString identifierPacked = { const_cast<char*>(tfae9fd.prepend("WHITESPACE").constData()+10), tfae9fd.size()-10 };callbackQInAppStore_ProductUnknown(this, productType, identifierPacked); };
 	void Signal_TransactionReady(QInAppTransaction * transaction) { callbackQInAppStore_TransactionReady(this, transaction); };

qml/qml.cpp

@@ -673,9 +673,9 @@ void QQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptorDefault(void* p
 class MyQQmlApplicationEngine: public QQmlApplicationEngine
 {
 public:
-	MyQQmlApplicationEngine(QObject *parent) : QQmlApplicationEngine(parent) {};
+	MyQQmlApplicationEngine(QObject *parent = Q_NULLPTR) : QQmlApplicationEngine(parent) {};
-	MyQQmlApplicationEngine(const QString &filePath, QObject *parent) : QQmlApplicationEngine(filePath, parent) {};
+	MyQQmlApplicationEngine(const QString &filePath, QObject *parent = Q_NULLPTR) : QQmlApplicationEngine(filePath, parent) {};
-	MyQQmlApplicationEngine(const QUrl &url, QObject *parent) : QQmlApplicationEngine(url, parent) {};
+	MyQQmlApplicationEngine(const QUrl &url, QObject *parent = Q_NULLPTR) : QQmlApplicationEngine(url, parent) {};
 	void load(const QString & filePath) { QByteArray t7df503 = filePath.toUtf8(); QtQml_PackedString filePathPacked = { const_cast<char*>(t7df503.prepend("WHITESPACE").constData()+10), t7df503.size()-10 };callbackQQmlApplicationEngine_Load2(this, filePathPacked); };
 	void load(const QUrl & url) { callbackQQmlApplicationEngine_Load(this, const_cast<QUrl*>(&url)); };
 	void loadData(const QByteArray & data, const QUrl & url) { callbackQQmlApplicationEngine_LoadData(this, const_cast<QByteArray*>(&data), const_cast<QUrl*>(&url)); };
@@ -892,11 +892,11 @@ void* QQmlApplicationEngine___rootObjects_newList(void* ptr)
 class MyQQmlComponent: public QQmlComponent
 {
 public:
-	MyQQmlComponent(QQmlEngine *engine, QObject *parent) : QQmlComponent(engine, parent) {};
+	MyQQmlComponent(QQmlEngine *engine, QObject *parent = Q_NULLPTR) : QQmlComponent(engine, parent) {};
-	MyQQmlComponent(QQmlEngine *engine, const QString &fileName, CompilationMode mode, QObject *parent) : QQmlComponent(engine, fileName, mode, parent) {};
+	MyQQmlComponent(QQmlEngine *engine, const QString &fileName, CompilationMode mode, QObject *parent = Q_NULLPTR) : QQmlComponent(engine, fileName, mode, parent) {};
-	MyQQmlComponent(QQmlEngine *engine, const QString &fileName, QObject *parent) : QQmlComponent(engine, fileName, parent) {};
+	MyQQmlComponent(QQmlEngine *engine, const QString &fileName, QObject *parent = Q_NULLPTR) : QQmlComponent(engine, fileName, parent) {};
-	MyQQmlComponent(QQmlEngine *engine, const QUrl &url, CompilationMode mode, QObject *parent) : QQmlComponent(engine, url, mode, parent) {};
+	MyQQmlComponent(QQmlEngine *engine, const QUrl &url, CompilationMode mode, QObject *parent = Q_NULLPTR) : QQmlComponent(engine, url, mode, parent) {};
-	MyQQmlComponent(QQmlEngine *engine, const QUrl &url, QObject *parent) : QQmlComponent(engine, url, parent) {};
+	MyQQmlComponent(QQmlEngine *engine, const QUrl &url, QObject *parent = Q_NULLPTR) : QQmlComponent(engine, url, parent) {};
 	QObject * beginCreate(QQmlContext * publicContext) { return static_cast<QObject*>(callbackQQmlComponent_BeginCreate(this, publicContext)); };
 	QObject * create(QQmlContext * context) { return static_cast<QObject*>(callbackQQmlComponent_Create(this, context)); };
 	void completeCreate() { callbackQQmlComponent_CompleteCreate(this); };
@@ -1412,8 +1412,8 @@ void* QQmlComponent_MetaObjectDefault(void* ptr)
 class MyQQmlContext: public QQmlContext
 {
 public:
-	MyQQmlContext(QQmlContext *parentContext, QObject *parent) : QQmlContext(parentContext, parent) {};
+	MyQQmlContext(QQmlContext *parentContext, QObject *parent = Q_NULLPTR) : QQmlContext(parentContext, parent) {};
-	MyQQmlContext(QQmlEngine *engine, QObject *parent) : QQmlContext(engine, parent) {};
+	MyQQmlContext(QQmlEngine *engine, QObject *parent = Q_NULLPTR) : QQmlContext(engine, parent) {};
 	 ~MyQQmlContext() { callbackQQmlContext_DestroyQQmlContext(this); };
 	bool event(QEvent * e) { return callbackQQmlContext_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQQmlContext_EventFilter(this, watched, event) != 0; };
@@ -1703,7 +1703,7 @@ void* QQmlContext_MetaObjectDefault(void* ptr)
 class MyQQmlEngine: public QQmlEngine
 {
 public:
-	MyQQmlEngine(QObject *parent) : QQmlEngine(parent) {};
+	MyQQmlEngine(QObject *parent = Q_NULLPTR) : QQmlEngine(parent) {};
 	bool event(QEvent * e) { return callbackQJSEngine_Event(this, e) != 0; };
 	void Signal_Exit(int retCode) { callbackQQmlEngine_Exit(this, retCode); };
 	void Signal_Quit() { callbackQQmlEngine_Quit(this); };
@@ -2071,8 +2071,8 @@ class MyQQmlExpression: public QQmlExpression
 {
 public:
 	MyQQmlExpression() : QQmlExpression() {};
-	MyQQmlExpression(QQmlContext *ctxt, QObject *scope, const QString &expression, QObject *parent) : QQmlExpression(ctxt, scope, expression, parent) {};
+	MyQQmlExpression(QQmlContext *ctxt, QObject *scope, const QString &expression, QObject *parent = Q_NULLPTR) : QQmlExpression(ctxt, scope, expression, parent) {};
-	MyQQmlExpression(const QQmlScriptString &script, QQmlContext *ctxt, QObject *scope, QObject *parent) : QQmlExpression(script, ctxt, scope, parent) {};
+	MyQQmlExpression(const QQmlScriptString &script, QQmlContext *ctxt = Q_NULLPTR, QObject *scope = Q_NULLPTR, QObject *parent = Q_NULLPTR) : QQmlExpression(script, ctxt, scope, parent) {};
 	void Signal_ValueChanged() { callbackQQmlExpression_ValueChanged(this); };
 	 ~MyQQmlExpression() { callbackQQmlExpression_DestroyQQmlExpression(this); };
 	bool event(QEvent * e) { return callbackQQmlExpression_Event(this, e) != 0; };
@@ -2398,7 +2398,7 @@ void* QQmlExpression_MetaObjectDefault(void* ptr)
 class MyQQmlExtensionPlugin: public QQmlExtensionPlugin
 {
 public:
-	MyQQmlExtensionPlugin(QObject *parent) : QQmlExtensionPlugin(parent) {};
+	MyQQmlExtensionPlugin(QObject *parent = Q_NULLPTR) : QQmlExtensionPlugin(parent) {};
 	void initializeEngine(QQmlEngine * engine, const char * uri) { QtQml_PackedString uriPacked = { const_cast<char*>(uri), -1 };callbackQQmlExtensionPlugin_InitializeEngine(this, engine, uriPacked); };
 	void registerTypes(const char * uri) { QtQml_PackedString uriPacked = { const_cast<char*>(uri), -1 };callbackQQmlExtensionPlugin_RegisterTypes(this, uriPacked); };
 	bool event(QEvent * e) { return callbackQQmlExtensionPlugin_Event(this, e) != 0; };
@@ -2598,7 +2598,7 @@ void* QQmlExtensionPlugin_MetaObjectDefault(void* ptr)
 class MyQQmlFileSelector: public QQmlFileSelector
 {
 public:
-	MyQQmlFileSelector(QQmlEngine *engine, QObject *parent) : QQmlFileSelector(engine, parent) {};
+	MyQQmlFileSelector(QQmlEngine *engine, QObject *parent = Q_NULLPTR) : QQmlFileSelector(engine, parent) {};
 	bool event(QEvent * e) { return callbackQQmlFileSelector_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQQmlFileSelector_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQQmlFileSelector_ChildEvent(this, event); };
@@ -2860,7 +2860,7 @@ int QQmlIncubationController_IncubatingObjectCount(void* ptr)
 class MyQQmlIncubator: public QQmlIncubator
 {
 public:
-	MyQQmlIncubator(IncubationMode mode) : QQmlIncubator(mode) {};
+	MyQQmlIncubator(IncubationMode mode = Asynchronous) : QQmlIncubator(mode) {};
 	void setInitialState(QObject * object) { callbackQQmlIncubator_SetInitialState(this, object); };
 	void statusChanged(QQmlIncubator::Status status) { callbackQQmlIncubator_StatusChanged(this, status); };
 };
@@ -3505,7 +3505,7 @@ int QQmlProperty_PropertyType(void* ptr)
 class MyQQmlPropertyMap: public QQmlPropertyMap
 {
 public:
-	MyQQmlPropertyMap(QObject *parent) : QQmlPropertyMap(parent) {};
+	MyQQmlPropertyMap(QObject *parent = Q_NULLPTR) : QQmlPropertyMap(parent) {};
 	QVariant updateValue(const QString & key, const QVariant & input) { QByteArray ta62f22 = key.toUtf8(); QtQml_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return *static_cast<QVariant*>(callbackQQmlPropertyMap_UpdateValue(this, keyPacked, const_cast<QVariant*>(&input))); };
 	void Signal_ValueChanged(const QString & key, const QVariant & value) { QByteArray ta62f22 = key.toUtf8(); QtQml_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQQmlPropertyMap_ValueChanged(this, keyPacked, const_cast<QVariant*>(&value)); };
 	 ~MyQQmlPropertyMap() { callbackQQmlPropertyMap_DestroyQQmlPropertyMap(this); };

quick/quick.cpp

@@ -262,7 +262,7 @@ char QQuickFramebufferObject_TextureFollowsItemSize(void* ptr)
 class MyQQuickImageProvider: public QQuickImageProvider
 {
 public:
-	MyQQuickImageProvider(ImageType type, Flags flags) : QQuickImageProvider(type, flags) {};
+	MyQQuickImageProvider(ImageType type, Flags flags = Flags()) : QQuickImageProvider(type, flags) {};
 	QImage requestImage(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return *static_cast<QImage*>(callbackQQuickImageProvider_RequestImage(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
 	QPixmap requestPixmap(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return *static_cast<QPixmap*>(callbackQQuickImageProvider_RequestPixmap(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
 	QQuickTextureFactory * requestTexture(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return static_cast<QQuickTextureFactory*>(callbackQQuickImageProvider_RequestTexture(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
@@ -576,7 +576,7 @@ void* QQuickImageResponse_MetaObjectDefault(void* ptr)
 class MyQQuickItem: public QQuickItem
 {
 public:
-	MyQQuickItem(QQuickItem *parent) : QQuickItem(parent) {};
+	MyQQuickItem(QQuickItem *parent = Q_NULLPTR) : QQuickItem(parent) {};
 	bool childMouseEventFilter(QQuickItem * item, QEvent * event) { return callbackQQuickItem_ChildMouseEventFilter(this, item, event) != 0; };
 	bool event(QEvent * ev) { return callbackQQuickItem_Event(this, ev) != 0; };
 	void classBegin() { callbackQQuickItem_ClassBegin(this); };
@@ -2090,7 +2090,7 @@ void* QQuickItemGrabResult_MetaObjectDefault(void* ptr)
 class MyQQuickPaintedItem: public QQuickPaintedItem
 {
 public:
-	MyQQuickPaintedItem(QQuickItem *parent) : QQuickPaintedItem(parent) {};
+	MyQQuickPaintedItem(QQuickItem *parent = Q_NULLPTR) : QQuickPaintedItem(parent) {};
 	void Signal_ContentsScaleChanged() { callbackQQuickPaintedItem_ContentsScaleChanged(this); };
 	void Signal_ContentsSizeChanged() { callbackQQuickPaintedItem_ContentsSizeChanged(this); };
 	void Signal_FillColorChanged() { callbackQQuickPaintedItem_FillColorChanged(this); };
@@ -2331,7 +2331,7 @@ double QQuickPaintedItem_ContentsScale(void* ptr)
 class MyQQuickRenderControl: public QQuickRenderControl
 {
 public:
-	MyQQuickRenderControl(QObject *parent) : QQuickRenderControl(parent) {};
+	MyQQuickRenderControl(QObject *parent = Q_NULLPTR) : QQuickRenderControl(parent) {};
 	QWindow * renderWindow(QPoint * offset) { return static_cast<QWindow*>(callbackQQuickRenderControl_RenderWindow(this, offset)); };
 	void Signal_RenderRequested() { callbackQQuickRenderControl_RenderRequested(this); };
 	void Signal_SceneChanged() { callbackQQuickRenderControl_SceneChanged(this); };
@@ -2992,8 +2992,8 @@ class MyQQuickView: public QQuickView
 {
 public:
 	MyQQuickView(QQmlEngine *engine, QWindow *parent) : QQuickView(engine, parent) {};
-	MyQQuickView(QWindow *parent) : QQuickView(parent) {};
+	MyQQuickView(QWindow *parent = Q_NULLPTR) : QQuickView(parent) {};
-	MyQQuickView(const QUrl &source, QWindow *parent) : QQuickView(source, parent) {};
+	MyQQuickView(const QUrl &source, QWindow *parent = Q_NULLPTR) : QQuickView(source, parent) {};
 	void setSource(const QUrl & url) { callbackQQuickView_SetSource(this, const_cast<QUrl*>(&url)); };
 	void Signal_StatusChanged(QQuickView::Status status) { callbackQQuickView_StatusChanged(this, status); };
 	 ~MyQQuickView() { callbackQQuickView_DestroyQQuickView(this); };
@@ -3212,8 +3212,8 @@ class MyQQuickWidget: public QQuickWidget
 {
 public:
 	MyQQuickWidget(QQmlEngine *engine, QWidget *parent) : QQuickWidget(engine, parent) {};
-	MyQQuickWidget(QWidget *parent) : QQuickWidget(parent) {};
+	MyQQuickWidget(QWidget *parent = Q_NULLPTR) : QQuickWidget(parent) {};
-	MyQQuickWidget(const QUrl &source, QWidget *parent) : QQuickWidget(source, parent) {};
+	MyQQuickWidget(const QUrl &source, QWidget *parent = Q_NULLPTR) : QQuickWidget(source, parent) {};
 	void Signal_SceneGraphError(QQuickWindow::SceneGraphError error, const QString & message) { QByteArray t6f9b9a = message.toUtf8(); QtQuick_PackedString messagePacked = { const_cast<char*>(t6f9b9a.prepend("WHITESPACE").constData()+10), t6f9b9a.size()-10 };callbackQQuickWidget_SceneGraphError(this, error, messagePacked); };
 	void setSource(const QUrl & url) { callbackQQuickWidget_SetSource(this, const_cast<QUrl*>(&url)); };
 	void Signal_StatusChanged(QQuickWidget::Status status) { callbackQQuickWidget_StatusChanged(this, status); };
@@ -3902,7 +3902,7 @@ void* QQuickWidget_MetaObjectDefault(void* ptr)
 class MyQQuickWindow: public QQuickWindow
 {
 public:
-	MyQQuickWindow(QWindow *parent) : QQuickWindow(parent) {};
+	MyQQuickWindow(QWindow *parent = Q_NULLPTR) : QQuickWindow(parent) {};
 	bool event(QEvent * e) { return callbackQQuickWindow_Event(this, e) != 0; };
 	void Signal_ActiveFocusItemChanged() { callbackQQuickWindow_ActiveFocusItemChanged(this); };
 	void Signal_AfterAnimating() { callbackQQuickWindow_AfterAnimating(this); };
@@ -5357,7 +5357,7 @@ int QSGDynamicTexture_TextureIdDefault(void* ptr)
 class MyQSGEngine: public QSGEngine
 {
 public:
-	MyQSGEngine(QObject *parent) : QSGEngine(parent) {};
+	MyQSGEngine(QObject *parent = Q_NULLPTR) : QSGEngine(parent) {};
 	bool event(QEvent * e) { return callbackQSGEngine_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSGEngine_EventFilter(this, watched, event) != 0; };
 	void childEvent(QChildEvent * event) { callbackQSGEngine_ChildEvent(this, event); };

script/script.cpp

@@ -914,7 +914,7 @@ char QScriptEngineAgent_SupportsExtensionDefault(void* ptr, long long extension)
 class MyQScriptExtensionPlugin: public QScriptExtensionPlugin
 {
 public:
-	MyQScriptExtensionPlugin(QObject *parent) : QScriptExtensionPlugin(parent) {};
+	MyQScriptExtensionPlugin(QObject *parent = Q_NULLPTR) : QScriptExtensionPlugin(parent) {};
 	void initialize(const QString & key, QScriptEngine * engine) { QByteArray ta62f22 = key.toUtf8(); QtScript_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };callbackQScriptExtensionPlugin_Initialize(this, keyPacked, engine); };
 	QStringList keys() const { return QString(callbackQScriptExtensionPlugin_Keys(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
 	bool event(QEvent * e) { return callbackQScriptExtensionPlugin_Event(this, e) != 0; };

scripttools/scripttools.cpp

@@ -43,7 +43,7 @@
 class MyQScriptEngineDebugger: public QScriptEngineDebugger
 {
 public:
-	MyQScriptEngineDebugger(QObject *parent) : QScriptEngineDebugger(parent) {};
+	MyQScriptEngineDebugger(QObject *parent = Q_NULLPTR) : QScriptEngineDebugger(parent) {};
 	void Signal_EvaluationResumed() { callbackQScriptEngineDebugger_EvaluationResumed(this); };
 	void Signal_EvaluationSuspended() { callbackQScriptEngineDebugger_EvaluationSuspended(this); };
 	bool event(QEvent * e) { return callbackQScriptEngineDebugger_Event(this, e) != 0; };

scxml/scxml.cpp

@@ -517,7 +517,7 @@ void* QScxmlDynamicScxmlServiceFactory___QScxmlDynamicScxmlServiceFactory_parame
 class MyQScxmlEcmaScriptDataModel: public QScxmlEcmaScriptDataModel
 {
 public:
-	MyQScxmlEcmaScriptDataModel(QObject *parent) : QScxmlEcmaScriptDataModel(parent) {};
+	MyQScxmlEcmaScriptDataModel(QObject *parent = nullptr) : QScxmlEcmaScriptDataModel(parent) {};
 	bool setScxmlProperty(const QString & name, const QVariant & value, const QString & context) { QByteArray t6ae999 = name.toUtf8(); QtScxml_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };QByteArray tec2727 = context.toUtf8(); QtScxml_PackedString contextPacked = { const_cast<char*>(tec2727.prepend("WHITESPACE").constData()+10), tec2727.size()-10 };return callbackQScxmlEcmaScriptDataModel_SetScxmlProperty(this, namePacked, const_cast<QVariant*>(&value), contextPacked) != 0; };
 	bool setup(const QVariantMap & initialDataValues) { return callbackQScxmlEcmaScriptDataModel_Setup(this, ({ QMap<QString, QVariant>* tmpValue = new QMap<QString, QVariant>(initialDataValues); QtScxml_PackedList { tmpValue, tmpValue->size() }; })) != 0; };
 	void setScxmlEvent(const QScxmlEvent & event) { callbackQScxmlEcmaScriptDataModel_SetScxmlEvent(this, const_cast<QScxmlEvent*>(&event)); };
@@ -1188,7 +1188,7 @@ void* QScxmlInvokableServiceFactory_MetaObjectDefault(void* ptr)
 class MyQScxmlNullDataModel: public QScxmlNullDataModel
 {
 public:
-	MyQScxmlNullDataModel(QObject *parent) : QScxmlNullDataModel(parent) {};
+	MyQScxmlNullDataModel(QObject *parent = nullptr) : QScxmlNullDataModel(parent) {};
 	bool setScxmlProperty(const QString & name, const QVariant & value, const QString & context) { QByteArray t6ae999 = name.toUtf8(); QtScxml_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };QByteArray tec2727 = context.toUtf8(); QtScxml_PackedString contextPacked = { const_cast<char*>(tec2727.prepend("WHITESPACE").constData()+10), tec2727.size()-10 };return callbackQScxmlNullDataModel_SetScxmlProperty(this, namePacked, const_cast<QVariant*>(&value), contextPacked) != 0; };
 	bool setup(const QVariantMap & initialDataValues) { return callbackQScxmlNullDataModel_Setup(this, ({ QMap<QString, QVariant>* tmpValue = new QMap<QString, QVariant>(initialDataValues); QtScxml_PackedList { tmpValue, tmpValue->size() }; })) != 0; };
 	void setScxmlEvent(const QScxmlEvent & event) { callbackQScxmlNullDataModel_SetScxmlEvent(this, const_cast<QScxmlEvent*>(&event)); };
@@ -1307,7 +1307,7 @@ char QScxmlNullDataModel_HasScxmlPropertyDefault(void* ptr, char* name)
 class MyQScxmlStateMachine: public QScxmlStateMachine
 {
 public:
-	MyQScxmlStateMachine(const QMetaObject *metaObject, QObject *parent) : QScxmlStateMachine(metaObject, parent) {};
+	MyQScxmlStateMachine(const QMetaObject *metaObject, QObject *parent = nullptr) : QScxmlStateMachine(metaObject, parent) {};
 	bool init() { return callbackQScxmlStateMachine_Init(this) != 0; };
 	void Signal_DataModelChanged(QScxmlDataModel * model) { callbackQScxmlStateMachine_DataModelChanged(this, model); };
 	void Signal_Finished() { callbackQScxmlStateMachine_Finished(this); };

sensors/sensors.cpp

@@ -106,7 +106,7 @@
 class MyQAccelerometer: public QAccelerometer
 {
 public:
-	MyQAccelerometer(QObject *parent) : QAccelerometer(parent) {};
+	MyQAccelerometer(QObject *parent = Q_NULLPTR) : QAccelerometer(parent) {};
 	void Signal_AccelerationModeChanged(QAccelerometer::AccelerationMode accelerationMode) { callbackQAccelerometer_AccelerationModeChanged(this, accelerationMode); };
 	 ~MyQAccelerometer() { callbackQAccelerometer_DestroyQAccelerometer(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
@@ -284,7 +284,7 @@ double QAccelerometerReading_Z(void* ptr)
 class MyQAltimeter: public QAltimeter
 {
 public:
-	MyQAltimeter(QObject *parent) : QAltimeter(parent) {};
+	MyQAltimeter(QObject *parent = Q_NULLPTR) : QAltimeter(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -447,7 +447,7 @@ long long QAmbientLightReading_LightLevel(void* ptr)
 class MyQAmbientLightSensor: public QAmbientLightSensor
 {
 public:
-	MyQAmbientLightSensor(QObject *parent) : QAmbientLightSensor(parent) {};
+	MyQAmbientLightSensor(QObject *parent = Q_NULLPTR) : QAmbientLightSensor(parent) {};
 	 ~MyQAmbientLightSensor() { callbackQAmbientLightSensor_DestroyQAmbientLightSensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -579,7 +579,7 @@ double QAmbientTemperatureReading_Temperature(void* ptr)
 class MyQAmbientTemperatureSensor: public QAmbientTemperatureSensor
 {
 public:
-	MyQAmbientTemperatureSensor(QObject *parent) : QAmbientTemperatureSensor(parent) {};
+	MyQAmbientTemperatureSensor(QObject *parent = Q_NULLPTR) : QAmbientTemperatureSensor(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -668,7 +668,7 @@ struct QtSensors_PackedString QAmbientTemperatureSensor_QAmbientTemperatureSenso
 class MyQCompass: public QCompass
 {
 public:
-	MyQCompass(QObject *parent) : QCompass(parent) {};
+	MyQCompass(QObject *parent = Q_NULLPTR) : QCompass(parent) {};
 	 ~MyQCompass() { callbackQCompass_DestroyQCompass(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -847,7 +847,7 @@ double QDistanceReading_Distance(void* ptr)
 class MyQDistanceSensor: public QDistanceSensor
 {
 public:
-	MyQDistanceSensor(QObject *parent) : QDistanceSensor(parent) {};
+	MyQDistanceSensor(QObject *parent = Q_NULLPTR) : QDistanceSensor(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -936,7 +936,7 @@ struct QtSensors_PackedString QDistanceSensor_QDistanceSensor_Type()
 class MyQGyroscope: public QGyroscope
 {
 public:
-	MyQGyroscope(QObject *parent) : QGyroscope(parent) {};
+	MyQGyroscope(QObject *parent = Q_NULLPTR) : QGyroscope(parent) {};
 	 ~MyQGyroscope() { callbackQGyroscope_DestroyQGyroscope(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -1125,7 +1125,7 @@ char QHolsterReading_Holstered(void* ptr)
 class MyQHolsterSensor: public QHolsterSensor
 {
 public:
-	MyQHolsterSensor(QObject *parent) : QHolsterSensor(parent) {};
+	MyQHolsterSensor(QObject *parent = Q_NULLPTR) : QHolsterSensor(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -1251,7 +1251,7 @@ double QIRProximityReading_Reflectance(void* ptr)
 class MyQIRProximitySensor: public QIRProximitySensor
 {
 public:
-	MyQIRProximitySensor(QObject *parent) : QIRProximitySensor(parent) {};
+	MyQIRProximitySensor(QObject *parent = Q_NULLPTR) : QIRProximitySensor(parent) {};
 	 ~MyQIRProximitySensor() { callbackQIRProximitySensor_DestroyQIRProximitySensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -1383,7 +1383,7 @@ double QLightReading_Lux(void* ptr)
 class MyQLightSensor: public QLightSensor
 {
 public:
-	MyQLightSensor(QObject *parent) : QLightSensor(parent) {};
+	MyQLightSensor(QObject *parent = Q_NULLPTR) : QLightSensor(parent) {};
 	void Signal_FieldOfViewChanged(qreal fieldOfView) { callbackQLightSensor_FieldOfViewChanged(this, fieldOfView); };
 	 ~MyQLightSensor() { callbackQLightSensor_DestroyQLightSensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
@@ -1504,7 +1504,7 @@ struct QtSensors_PackedString QLightSensor_QLightSensor_Type()
 class MyQMagnetometer: public QMagnetometer
 {
 public:
-	MyQMagnetometer(QObject *parent) : QMagnetometer(parent) {};
+	MyQMagnetometer(QObject *parent = Q_NULLPTR) : QMagnetometer(parent) {};
 	void Signal_ReturnGeoValuesChanged(bool returnGeoValues) { callbackQMagnetometer_ReturnGeoValuesChanged(this, returnGeoValues); };
 	 ~MyQMagnetometer() { callbackQMagnetometer_DestroyQMagnetometer(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
@@ -1729,7 +1729,7 @@ long long QOrientationReading_Orientation(void* ptr)
 class MyQOrientationSensor: public QOrientationSensor
 {
 public:
-	MyQOrientationSensor(QObject *parent) : QOrientationSensor(parent) {};
+	MyQOrientationSensor(QObject *parent = Q_NULLPTR) : QOrientationSensor(parent) {};
 	 ~MyQOrientationSensor() { callbackQOrientationSensor_DestroyQOrientationSensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -1871,7 +1871,7 @@ double QPressureReading_Temperature(void* ptr)
 class MyQPressureSensor: public QPressureSensor
 {
 public:
-	MyQPressureSensor(QObject *parent) : QPressureSensor(parent) {};
+	MyQPressureSensor(QObject *parent = Q_NULLPTR) : QPressureSensor(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -1997,7 +1997,7 @@ char QProximityReading_Close(void* ptr)
 class MyQProximitySensor: public QProximitySensor
 {
 public:
-	MyQProximitySensor(QObject *parent) : QProximitySensor(parent) {};
+	MyQProximitySensor(QObject *parent = Q_NULLPTR) : QProximitySensor(parent) {};
 	 ~MyQProximitySensor() { callbackQProximitySensor_DestroyQProximitySensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
@@ -2139,7 +2139,7 @@ double QRotationReading_Z(void* ptr)
 class MyQRotationSensor: public QRotationSensor
 {
 public:
-	MyQRotationSensor(QObject *parent) : QRotationSensor(parent) {};
+	MyQRotationSensor(QObject *parent = Q_NULLPTR) : QRotationSensor(parent) {};
 	void Signal_HasZChanged(bool hasZ) { callbackQRotationSensor_HasZChanged(this, hasZ); };
 	 ~MyQRotationSensor() { callbackQRotationSensor_DestroyQRotationSensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
@@ -2260,7 +2260,7 @@ struct QtSensors_PackedString QRotationSensor_QRotationSensor_Type()
 class MyQSensor: public QSensor
 {
 public:
-	MyQSensor(const QByteArray &type, QObject *parent) : QSensor(type, parent) {};
+	MyQSensor(const QByteArray &type, QObject *parent = Q_NULLPTR) : QSensor(type, parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };
@@ -3591,7 +3591,7 @@ void QSensorFilter_SetM_sensor(void* ptr, void* vqs)
 class MyQSensorGesture: public QSensorGesture
 {
 public:
-	MyQSensorGesture(const QStringList &ids, QObject *parent) : QSensorGesture(ids, parent) {};
+	MyQSensorGesture(const QStringList &ids, QObject *parent = Q_NULLPTR) : QSensorGesture(ids, parent) {};
 	#ifdef Q_QDOC
 		void Signal_Detected(QString gestureId) { QByteArray t7bc790 = gestureId.toUtf8(); QtSensors_PackedString gestureIdPacked = { const_cast<char*>(t7bc790.prepend("WHITESPACE").constData()+10), t7bc790.size()-10 };callbackQSensorGesture_Detected(this, gestureIdPacked); };
 	#endif
@@ -3828,7 +3828,7 @@ void* QSensorGesture_MetaObjectDefault(void* ptr)
 class MyQSensorGestureManager: public QSensorGestureManager
 {
 public:
-	MyQSensorGestureManager(QObject *parent) : QSensorGestureManager(parent) {};
+	MyQSensorGestureManager(QObject *parent = Q_NULLPTR) : QSensorGestureManager(parent) {};
 	void Signal_NewSensorGestureAvailable() { callbackQSensorGestureManager_NewSensorGestureAvailable(this); };
 	bool event(QEvent * e) { return callbackQSensorGestureManager_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSensorGestureManager_EventFilter(this, watched, event) != 0; };
@@ -4102,7 +4102,7 @@ void* QSensorGesturePluginInterface___createRecognizers_newList(void* ptr)
 class MyQSensorGestureRecognizer: public QSensorGestureRecognizer
 {
 public:
-	MyQSensorGestureRecognizer(QObject *parent) : QSensorGestureRecognizer(parent) {};
+	MyQSensorGestureRecognizer(QObject *parent = Q_NULLPTR) : QSensorGestureRecognizer(parent) {};
 	bool isActive() { return callbackQSensorGestureRecognizer_IsActive(this) != 0; };
 	bool start() { return callbackQSensorGestureRecognizer_Start(this) != 0; };
 	bool stop() { return callbackQSensorGestureRecognizer_Stop(this) != 0; };
@@ -4920,7 +4920,7 @@ char QTapReading_IsDoubleTap(void* ptr)
 class MyQTapSensor: public QTapSensor
 {
 public:
-	MyQTapSensor(QObject *parent) : QTapSensor(parent) {};
+	MyQTapSensor(QObject *parent = Q_NULLPTR) : QTapSensor(parent) {};
 	void Signal_ReturnDoubleTapEventsChanged(bool returnDoubleTapEvents) { callbackQTapSensor_ReturnDoubleTapEventsChanged(this, returnDoubleTapEvents); };
 	 ~MyQTapSensor() { callbackQTapSensor_DestroyQTapSensor(this); };
 	bool start() { return callbackQSensor_Start(this) != 0; };
@@ -5088,7 +5088,7 @@ double QTiltReading_YRotation(void* ptr)
 class MyQTiltSensor: public QTiltSensor
 {
 public:
-	MyQTiltSensor(QObject *parent) : QTiltSensor(parent) {};
+	MyQTiltSensor(QObject *parent = Q_NULLPTR) : QTiltSensor(parent) {};
 	bool start() { return callbackQSensor_Start(this) != 0; };
 	void Signal_ActiveChanged() { callbackQSensor_ActiveChanged(this); };
 	void Signal_AlwaysOnChanged() { callbackQSensor_AlwaysOnChanged(this); };

serialbus/serialbus.cpp

@@ -212,7 +212,7 @@ void* QCanBus_MetaObjectDefault(void* ptr)
 class MyQCanBusDevice: public QCanBusDevice
 {
 public:
-	MyQCanBusDevice(QObject *parent) : QCanBusDevice(parent) {};
+	MyQCanBusDevice(QObject *parent = nullptr) : QCanBusDevice(parent) {};
 	QString interpretErrorFrame(const QCanBusFrame & frame) { return QString(callbackQCanBusDevice_InterpretErrorFrame(this, const_cast<QCanBusFrame*>(&frame))); };
 	bool open() { return callbackQCanBusDevice_Open(this) != 0; };
 	bool waitForFramesReceived(int msecs) { return callbackQCanBusDevice_WaitForFramesReceived(this, msecs) != 0; };
@@ -752,7 +752,7 @@ unsigned int QCanBusFrame_FrameId(void* ptr)
 class MyQModbusClient: public QModbusClient
 {
 public:
-	MyQModbusClient(QObject *parent) : QModbusClient(parent) {};
+	MyQModbusClient(QObject *parent = nullptr) : QModbusClient(parent) {};
 	bool processPrivateResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessPrivateResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	bool processResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	void Signal_TimeoutChanged(int newTimeout) { callbackQModbusClient_TimeoutChanged(this, newTimeout); };
@@ -1056,7 +1056,7 @@ void* QModbusDataUnit___values_newList(void* ptr)
 class MyQModbusDevice: public QModbusDevice
 {
 public:
-	MyQModbusDevice(QObject *parent) : QModbusDevice(parent) {};
+	MyQModbusDevice(QObject *parent = nullptr) : QModbusDevice(parent) {};
 	bool open() { return callbackQModbusDevice_Open(this) != 0; };
 	void close() { callbackQModbusDevice_Close(this); };
 	void Signal_ErrorOccurred(QModbusDevice::Error error) { callbackQModbusDevice_ErrorOccurred(this, error); };
@@ -1656,7 +1656,7 @@ void* QModbusPdu___encode_vector_newList2(void* ptr)
 class MyQModbusReply: public QModbusReply
 {
 public:
-	MyQModbusReply(ReplyType type, int serverAddress, QObject *parent) : QModbusReply(type, serverAddress, parent) {};
+	MyQModbusReply(ReplyType type, int serverAddress, QObject *parent = nullptr) : QModbusReply(type, serverAddress, parent) {};
 	void Signal_ErrorOccurred(QModbusDevice::Error error) { callbackQModbusReply_ErrorOccurred(this, error); };
 	void Signal_Finished() { callbackQModbusReply_Finished(this); };
 	bool event(QEvent * e) { return callbackQModbusReply_Event(this, e) != 0; };
@@ -1902,7 +1902,7 @@ class MyQModbusRequest: public QModbusRequest
 {
 public:
 	MyQModbusRequest() : QModbusRequest() {};
-	MyQModbusRequest(FunctionCode code, const QByteArray &data) : QModbusRequest(code, data) {};
+	MyQModbusRequest(FunctionCode code, const QByteArray &data = QByteArray()) : QModbusRequest(code, data) {};
 	MyQModbusRequest(const QModbusPdu &pdu) : QModbusRequest(pdu) {};
 	void setFunctionCode(QModbusPdu::FunctionCode code) { callbackQModbusPdu_SetFunctionCode(this, code); };
 };
@@ -1936,7 +1936,7 @@ class MyQModbusResponse: public QModbusResponse
 {
 public:
 	MyQModbusResponse() : QModbusResponse() {};
-	MyQModbusResponse(FunctionCode code, const QByteArray &data) : QModbusResponse(code, data) {};
+	MyQModbusResponse(FunctionCode code, const QByteArray &data = QByteArray()) : QModbusResponse(code, data) {};
 	MyQModbusResponse(const QModbusPdu &pdu) : QModbusResponse(pdu) {};
 	void setFunctionCode(QModbusPdu::FunctionCode code) { callbackQModbusPdu_SetFunctionCode(this, code); };
 };
@@ -1969,7 +1969,7 @@ int QModbusResponse_QModbusResponse_MinimumDataSize(void* response)
 class MyQModbusRtuSerialMaster: public QModbusRtuSerialMaster
 {
 public:
-	MyQModbusRtuSerialMaster(QObject *parent) : QModbusRtuSerialMaster(parent) {};
+	MyQModbusRtuSerialMaster(QObject *parent = nullptr) : QModbusRtuSerialMaster(parent) {};
 	bool processPrivateResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessPrivateResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	bool processResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	void Signal_TimeoutChanged(int newTimeout) { callbackQModbusClient_TimeoutChanged(this, newTimeout); };
@@ -2044,7 +2044,7 @@ int QModbusRtuSerialMaster_InterFrameDelay(void* ptr)
 class MyQModbusRtuSerialSlave: public QModbusRtuSerialSlave
 {
 public:
-	MyQModbusRtuSerialSlave(QObject *parent) : QModbusRtuSerialSlave(parent) {};
+	MyQModbusRtuSerialSlave(QObject *parent = nullptr) : QModbusRtuSerialSlave(parent) {};
 	QModbusResponse processPrivateRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessPrivateRequest(this, const_cast<QModbusPdu*>(&request))); };
 	QModbusResponse processRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessRequest(this, const_cast<QModbusPdu*>(&request))); };
 	
@@ -2120,7 +2120,7 @@ void QModbusRtuSerialSlave_DestroyQModbusRtuSerialSlave(void* ptr)
 class MyQModbusServer: public QModbusServer
 {
 public:
-	MyQModbusServer(QObject *parent) : QModbusServer(parent) {};
+	MyQModbusServer(QObject *parent = nullptr) : QModbusServer(parent) {};
 	QModbusResponse processPrivateRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessPrivateRequest(this, const_cast<QModbusPdu*>(&request))); };
 	QModbusResponse processRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessRequest(this, const_cast<QModbusPdu*>(&request))); };
 	bool setValue(int option, const QVariant & newValue) { return callbackQModbusServer_SetValue(this, option, const_cast<QVariant*>(&newValue)) != 0; };
@@ -2379,7 +2379,7 @@ void QModbusServer_CloseDefault(void* ptr)
 class MyQModbusTcpClient: public QModbusTcpClient
 {
 public:
-	MyQModbusTcpClient(QObject *parent) : QModbusTcpClient(parent) {};
+	MyQModbusTcpClient(QObject *parent = nullptr) : QModbusTcpClient(parent) {};
 	bool processPrivateResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessPrivateResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	bool processResponse(const QModbusResponse & response, QModbusDataUnit * data) { return callbackQModbusClient_ProcessResponse(this, const_cast<QModbusResponse*>(&response), data) != 0; };
 	void Signal_TimeoutChanged(int newTimeout) { callbackQModbusClient_TimeoutChanged(this, newTimeout); };
@@ -2449,7 +2449,7 @@ void QModbusTcpClient_DestroyQModbusTcpClient(void* ptr)
 class MyQModbusTcpServer: public QModbusTcpServer
 {
 public:
-	MyQModbusTcpServer(QObject *parent) : QModbusTcpServer(parent) {};
+	MyQModbusTcpServer(QObject *parent = nullptr) : QModbusTcpServer(parent) {};
 	QModbusResponse processPrivateRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessPrivateRequest(this, const_cast<QModbusPdu*>(&request))); };
 	QModbusResponse processRequest(const QModbusPdu & request) { return *static_cast<QModbusResponse*>(callbackQModbusServer_ProcessRequest(this, const_cast<QModbusPdu*>(&request))); };
 	bool setValue(int option, const QVariant & newValue) { return callbackQModbusServer_SetValue(this, option, const_cast<QVariant*>(&newValue)) != 0; };

serialport/serialport.cpp

@@ -44,9 +44,9 @@
 class MyQSerialPort: public QSerialPort
 {
 public:
-	MyQSerialPort(QObject *parent) : QSerialPort(parent) {};
+	MyQSerialPort(QObject *parent = nullptr) : QSerialPort(parent) {};
-	MyQSerialPort(const QSerialPortInfo &serialPortInfo, QObject *parent) : QSerialPort(serialPortInfo, parent) {};
+	MyQSerialPort(const QSerialPortInfo &serialPortInfo, QObject *parent = nullptr) : QSerialPort(serialPortInfo, parent) {};
-	MyQSerialPort(const QString &name, QObject *parent) : QSerialPort(name, parent) {};
+	MyQSerialPort(const QString &name, QObject *parent = nullptr) : QSerialPort(name, parent) {};
 	bool waitForBytesWritten(int msecs) { return callbackQSerialPort_WaitForBytesWritten(this, msecs) != 0; };
 	bool waitForReadyRead(int msecs) { return callbackQSerialPort_WaitForReadyRead(this, msecs) != 0; };
 	qint64 readData(char * data, qint64 maxSize) { QtSerialPort_PackedString dataPacked = { data, maxSize };return callbackQSerialPort_ReadData(this, dataPacked, maxSize); };

speech/speech.cpp

@@ -41,8 +41,8 @@
 class MyQTextToSpeech: public QTextToSpeech
 {
 public:
-	MyQTextToSpeech(QObject *parent) : QTextToSpeech(parent) {};
+	MyQTextToSpeech(QObject *parent = nullptr) : QTextToSpeech(parent) {};
-	MyQTextToSpeech(const QString &engine, QObject *parent) : QTextToSpeech(engine, parent) {};
+	MyQTextToSpeech(const QString &engine, QObject *parent = nullptr) : QTextToSpeech(engine, parent) {};
 	void Signal_LocaleChanged(const QLocale & locale) { callbackQTextToSpeech_LocaleChanged(this, const_cast<QLocale*>(&locale)); };
 	void pause() { callbackQTextToSpeech_Pause(this); };
 	void Signal_PitchChanged(double pitch) { callbackQTextToSpeech_PitchChanged(this, pitch); };

sql/sql.cpp

@@ -311,7 +311,7 @@ struct QtSql_PackedString QSqlDatabase_QSqlDatabase_DefaultConnection()
 class MyQSqlDriver: public QSqlDriver
 {
 public:
-	MyQSqlDriver(QObject *parent) : QSqlDriver(parent) {};
+	MyQSqlDriver(QObject *parent = Q_NULLPTR) : QSqlDriver(parent) {};
 	bool beginTransaction() { return callbackQSqlDriver_BeginTransaction(this) != 0; };
 	bool commitTransaction() { return callbackQSqlDriver_CommitTransaction(this) != 0; };
 	bool open(const QString & db, const QString & user, const QString & password, const QString & host, int port, const QString & options) { QByteArray t0352a8 = db.toUtf8(); QtSql_PackedString dbPacked = { const_cast<char*>(t0352a8.prepend("WHITESPACE").constData()+10), t0352a8.size()-10 };QByteArray t12dea9 = user.toUtf8(); QtSql_PackedString userPacked = { const_cast<char*>(t12dea9.prepend("WHITESPACE").constData()+10), t12dea9.size()-10 };QByteArray t5baa61 = password.toUtf8(); QtSql_PackedString passwordPacked = { const_cast<char*>(t5baa61.prepend("WHITESPACE").constData()+10), t5baa61.size()-10 };QByteArray t86dd1c = host.toUtf8(); QtSql_PackedString hostPacked = { const_cast<char*>(t86dd1c.prepend("WHITESPACE").constData()+10), t86dd1c.size()-10 };QByteArray t513f8d = options.toUtf8(); QtSql_PackedString optionsPacked = { const_cast<char*>(t513f8d.prepend("WHITESPACE").constData()+10), t513f8d.size()-10 };return callbackQSqlDriver_Open(this, dbPacked, userPacked, passwordPacked, hostPacked, port, optionsPacked) != 0; };
@@ -806,7 +806,7 @@ void* QSqlDriverCreatorBase_CreateObject(void* ptr)
 class MyQSqlDriverPlugin: public QSqlDriverPlugin
 {
 public:
-	MyQSqlDriverPlugin(QObject *parent) : QSqlDriverPlugin(parent) {};
+	MyQSqlDriverPlugin(QObject *parent = Q_NULLPTR) : QSqlDriverPlugin(parent) {};
 	QSqlDriver * create(const QString & key) { QByteArray ta62f22 = key.toUtf8(); QtSql_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return static_cast<QSqlDriver*>(callbackQSqlDriverPlugin_Create(this, keyPacked)); };
 	bool event(QEvent * e) { return callbackQSqlDriverPlugin_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSqlDriverPlugin_EventFilter(this, watched, event) != 0; };
@@ -1465,7 +1465,7 @@ void* QSqlQuery_____boundValues_keyList_newList(void* ptr)
 class MyQSqlQueryModel: public QSqlQueryModel
 {
 public:
-	MyQSqlQueryModel(QObject *parent) : QSqlQueryModel(parent) {};
+	MyQSqlQueryModel(QObject *parent = Q_NULLPTR) : QSqlQueryModel(parent) {};
 	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQSqlQueryModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQSqlQueryModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQSqlQueryModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
@@ -2682,7 +2682,7 @@ char QSqlRelation_IsValid(void* ptr)
 class MyQSqlRelationalDelegate: public QSqlRelationalDelegate
 {
 public:
-	MyQSqlRelationalDelegate(QObject *parent) : QSqlRelationalDelegate(parent) {};
+	MyQSqlRelationalDelegate(QObject *parent = 0) : QSqlRelationalDelegate(parent) {};
 	QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const { return static_cast<QWidget*>(callbackQSqlRelationalDelegate_CreateEditor(const_cast<void*>(static_cast<const void*>(this)), parent, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index))); };
 	void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const { callbackQSqlRelationalDelegate_SetModelData(const_cast<void*>(static_cast<const void*>(this)), editor, model, const_cast<QModelIndex*>(&index)); };
 	bool editorEvent(QEvent * event, QAbstractItemModel * model, const QStyleOptionViewItem & option, const QModelIndex & index) { return callbackQSqlRelationalDelegate_EditorEvent(this, event, model, const_cast<QStyleOptionViewItem*>(&option), const_cast<QModelIndex*>(&index)) != 0; };
@@ -2946,7 +2946,7 @@ void* QSqlRelationalDelegate_MetaObjectDefault(void* ptr)
 class MyQSqlRelationalTableModel: public QSqlRelationalTableModel
 {
 public:
-	MyQSqlRelationalTableModel(QObject *parent, QSqlDatabase db) : QSqlRelationalTableModel(parent, db) {};
+	MyQSqlRelationalTableModel(QObject *parent = Q_NULLPTR, QSqlDatabase db = QSqlDatabase()) : QSqlRelationalTableModel(parent, db) {};
 	bool insertRowIntoTable(const QSqlRecord & values) { return callbackQSqlTableModel_InsertRowIntoTable(this, const_cast<QSqlRecord*>(&values)) != 0; };
 	bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQSqlQueryModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
 	bool select() { return callbackQSqlRelationalTableModel_Select(this) != 0; };
@@ -3507,7 +3507,7 @@ void* QSqlResult___boundValues_newList(void* ptr)
 class MyQSqlTableModel: public QSqlTableModel
 {
 public:
-	MyQSqlTableModel(QObject *parent, QSqlDatabase db) : QSqlTableModel(parent, db) {};
+	MyQSqlTableModel(QObject *parent = Q_NULLPTR, QSqlDatabase db = QSqlDatabase()) : QSqlTableModel(parent, db) {};
 	bool deleteRowFromTable(int row) { return callbackQSqlTableModel_DeleteRowFromTable(this, row) != 0; };
 	bool insertRowIntoTable(const QSqlRecord & values) { return callbackQSqlTableModel_InsertRowIntoTable(this, const_cast<QSqlRecord*>(&values)) != 0; };
 	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQSqlQueryModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };

svg/svg.cpp

@@ -89,8 +89,8 @@
 class MyQGraphicsSvgItem: public QGraphicsSvgItem
 {
 public:
-	MyQGraphicsSvgItem(QGraphicsItem *parent) : QGraphicsSvgItem(parent) {};
+	MyQGraphicsSvgItem(QGraphicsItem *parent = Q_NULLPTR) : QGraphicsSvgItem(parent) {};
-	MyQGraphicsSvgItem(const QString &fileName, QGraphicsItem *parent) : QGraphicsSvgItem(fileName, parent) {};
+	MyQGraphicsSvgItem(const QString &fileName, QGraphicsItem *parent = Q_NULLPTR) : QGraphicsSvgItem(fileName, parent) {};
 	void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) { callbackQGraphicsSvgItem_Paint(this, painter, const_cast<QStyleOptionGraphicsItem*>(option), widget); };
 	QRectF boundingRect() const { return *static_cast<QRectF*>(callbackQGraphicsSvgItem_BoundingRect(const_cast<void*>(static_cast<const void*>(this)))); };
 	int type() const { return callbackQGraphicsSvgItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
@@ -666,10 +666,10 @@ int QSvgGenerator_Resolution(void* ptr)
 class MyQSvgRenderer: public QSvgRenderer
 {
 public:
-	MyQSvgRenderer(QObject *parent) : QSvgRenderer(parent) {};
+	MyQSvgRenderer(QObject *parent = Q_NULLPTR) : QSvgRenderer(parent) {};
-	MyQSvgRenderer(QXmlStreamReader *contents, QObject *parent) : QSvgRenderer(contents, parent) {};
+	MyQSvgRenderer(QXmlStreamReader *contents, QObject *parent = Q_NULLPTR) : QSvgRenderer(contents, parent) {};
-	MyQSvgRenderer(const QByteArray &contents, QObject *parent) : QSvgRenderer(contents, parent) {};
+	MyQSvgRenderer(const QByteArray &contents, QObject *parent = Q_NULLPTR) : QSvgRenderer(contents, parent) {};
-	MyQSvgRenderer(const QString &filename, QObject *parent) : QSvgRenderer(filename, parent) {};
+	MyQSvgRenderer(const QString &filename, QObject *parent = Q_NULLPTR) : QSvgRenderer(filename, parent) {};
 	bool load(QXmlStreamReader * contents) { return callbackQSvgRenderer_Load3(this, contents) != 0; };
 	bool load(const QByteArray & contents) { return callbackQSvgRenderer_Load2(this, const_cast<QByteArray*>(&contents)) != 0; };
 	bool load(const QString & filename) { QByteArray t08deae = filename.toUtf8(); QtSvg_PackedString filenamePacked = { const_cast<char*>(t08deae.prepend("WHITESPACE").constData()+10), t08deae.size()-10 };return callbackQSvgRenderer_Load(this, filenamePacked) != 0; };
@@ -1118,8 +1118,8 @@ void* QSvgRenderer_MetaObjectDefault(void* ptr)
 class MyQSvgWidget: public QSvgWidget
 {
 public:
-	MyQSvgWidget(QWidget *parent) : QSvgWidget(parent) {};
+	MyQSvgWidget(QWidget *parent = Q_NULLPTR) : QSvgWidget(parent) {};
-	MyQSvgWidget(const QString &file, QWidget *parent) : QSvgWidget(file, parent) {};
+	MyQSvgWidget(const QString &file, QWidget *parent = Q_NULLPTR) : QSvgWidget(file, parent) {};
 	void load(const QByteArray & contents) { callbackQSvgWidget_Load2(this, const_cast<QByteArray*>(&contents)); };
 	void load(const QString & file) { QByteArray t971c41 = file.toUtf8(); QtSvg_PackedString filePacked = { const_cast<char*>(t971c41.prepend("WHITESPACE").constData()+10), t971c41.size()-10 };callbackQSvgWidget_Load(this, filePacked); };
 	void paintEvent(QPaintEvent * event) { callbackQSvgWidget_PaintEvent(this, event); };

uitools/uitools.cpp

@@ -46,7 +46,7 @@
 class MyQUiLoader: public QUiLoader
 {
 public:
-	MyQUiLoader(QObject *parent) : QUiLoader(parent) {};
+	MyQUiLoader(QObject *parent = Q_NULLPTR) : QUiLoader(parent) {};
 	QAction * createAction(QObject * parent, const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtUiTools_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return static_cast<QAction*>(callbackQUiLoader_CreateAction(this, parent, namePacked)); };
 	QActionGroup * createActionGroup(QObject * parent, const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtUiTools_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return static_cast<QActionGroup*>(callbackQUiLoader_CreateActionGroup(this, parent, namePacked)); };
 	QLayout * createLayout(const QString & className, QObject * parent, const QString & name) { QByteArray td80a05 = className.toUtf8(); QtUiTools_PackedString classNamePacked = { const_cast<char*>(td80a05.prepend("WHITESPACE").constData()+10), td80a05.size()-10 };QByteArray t6ae999 = name.toUtf8(); QtUiTools_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return static_cast<QLayout*>(callbackQUiLoader_CreateLayout(this, classNamePacked, parent, namePacked)); };

webchannel/webchannel.cpp

@@ -45,7 +45,7 @@
 class MyQWebChannel: public QWebChannel
 {
 public:
-	MyQWebChannel(QObject *parent) : QWebChannel(parent) {};
+	MyQWebChannel(QObject *parent = Q_NULLPTR) : QWebChannel(parent) {};
 	void Signal_BlockUpdatesChanged(bool block) { callbackQWebChannel_BlockUpdatesChanged(this, block); };
 	void connectTo(QWebChannelAbstractTransport * transport) { callbackQWebChannel_ConnectTo(this, transport); };
 	void disconnectFrom(QWebChannelAbstractTransport * transport) { callbackQWebChannel_DisconnectFrom(this, transport); };
@@ -366,7 +366,7 @@ void* QWebChannel_MetaObjectDefault(void* ptr)
 class MyQWebChannelAbstractTransport: public QWebChannelAbstractTransport
 {
 public:
-	MyQWebChannelAbstractTransport(QObject *parent) : QWebChannelAbstractTransport(parent) {};
+	MyQWebChannelAbstractTransport(QObject *parent = Q_NULLPTR) : QWebChannelAbstractTransport(parent) {};
 	void Signal_MessageReceived(const QJsonObject & message, QWebChannelAbstractTransport * transport) { callbackQWebChannelAbstractTransport_MessageReceived(this, const_cast<QJsonObject*>(&message), transport); };
 	void sendMessage(const QJsonObject & message) { callbackQWebChannelAbstractTransport_SendMessage(this, const_cast<QJsonObject*>(&message)); };
 	 ~MyQWebChannelAbstractTransport() { callbackQWebChannelAbstractTransport_DestroyQWebChannelAbstractTransport(this); };

webengine/webengine.cpp

@@ -99,7 +99,7 @@
 class MyQQuickWebEngineProfile: public QQuickWebEngineProfile
 {
 public:
-	MyQQuickWebEngineProfile(QObject *parent) : QQuickWebEngineProfile(parent) {};
+	MyQQuickWebEngineProfile(QObject *parent = Q_NULLPTR) : QQuickWebEngineProfile(parent) {};
 	void Signal_CachePathChanged() { callbackQQuickWebEngineProfile_CachePathChanged(this); };
 	void Signal_HttpAcceptLanguageChanged() { callbackQQuickWebEngineProfile_HttpAcceptLanguageChanged(this); };
 	void Signal_HttpCacheMaximumSizeChanged() { callbackQQuickWebEngineProfile_HttpCacheMaximumSizeChanged(this); };
@@ -1348,8 +1348,8 @@ char QWebEngineHistoryItem_IsValid(void* ptr)
 class MyQWebEnginePage: public QWebEnginePage
 {
 public:
-	MyQWebEnginePage(QObject *parent) : QWebEnginePage(parent) {};
+	MyQWebEnginePage(QObject *parent = Q_NULLPTR) : QWebEnginePage(parent) {};
-	MyQWebEnginePage(QWebEngineProfile *profile, QObject *parent) : QWebEnginePage(profile, parent) {};
+	MyQWebEnginePage(QWebEngineProfile *profile, QObject *parent = Q_NULLPTR) : QWebEnginePage(profile, parent) {};
 	QStringList chooseFiles(QWebEnginePage::FileSelectionMode mode, const QStringList & oldFiles, const QStringList & acceptedMimeTypes) { QByteArray t76015f = oldFiles.join("|").toUtf8(); QtWebEngine_PackedString oldFilesPacked = { const_cast<char*>(t76015f.prepend("WHITESPACE").constData()+10), t76015f.size()-10 };QByteArray t541092 = acceptedMimeTypes.join("|").toUtf8(); QtWebEngine_PackedString acceptedMimeTypesPacked = { const_cast<char*>(t541092.prepend("WHITESPACE").constData()+10), t541092.size()-10 };return QString(callbackQWebEnginePage_ChooseFiles(this, mode, oldFilesPacked, acceptedMimeTypesPacked)).split("|", QString::SkipEmptyParts); };
 	QWebEnginePage * createWindow(QWebEnginePage::WebWindowType ty) { return static_cast<QWebEnginePage*>(callbackQWebEnginePage_CreateWindow(this, ty)); };
 	bool acceptNavigationRequest(const QUrl & url, QWebEnginePage::NavigationType ty, bool isMainFrame) { return callbackQWebEnginePage_AcceptNavigationRequest(this, const_cast<QUrl*>(&url), ty, isMainFrame) != 0; };
@@ -2182,8 +2182,8 @@ void* QWebEnginePage_MetaObjectDefault(void* ptr)
 class MyQWebEngineProfile: public QWebEngineProfile
 {
 public:
-	MyQWebEngineProfile(QObject *parent) : QWebEngineProfile(parent) {};
+	MyQWebEngineProfile(QObject *parent = Q_NULLPTR) : QWebEngineProfile(parent) {};
-	MyQWebEngineProfile(const QString &storageName, QObject *parent) : QWebEngineProfile(storageName, parent) {};
+	MyQWebEngineProfile(const QString &storageName, QObject *parent = Q_NULLPTR) : QWebEngineProfile(storageName, parent) {};
 	void Signal_DownloadRequested(QWebEngineDownloadItem * download) { callbackQWebEngineProfile_DownloadRequested(this, download); };
 	bool event(QEvent * e) { return callbackQWebEngineProfile_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWebEngineProfile_EventFilter(this, watched, event) != 0; };
@@ -2888,7 +2888,7 @@ long long QWebEngineUrlRequestInfo_ResourceType(void* ptr)
 class MyQWebEngineUrlRequestInterceptor: public QWebEngineUrlRequestInterceptor
 {
 public:
-	MyQWebEngineUrlRequestInterceptor(QObject *p) : QWebEngineUrlRequestInterceptor(p) {};
+	MyQWebEngineUrlRequestInterceptor(QObject *p = Q_NULLPTR) : QWebEngineUrlRequestInterceptor(p) {};
 	void interceptRequest(QWebEngineUrlRequestInfo & info) { callbackQWebEngineUrlRequestInterceptor_InterceptRequest(this, static_cast<QWebEngineUrlRequestInfo*>(&info)); };
 	bool event(QEvent * e) { return callbackQWebEngineUrlRequestInterceptor_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWebEngineUrlRequestInterceptor_EventFilter(this, watched, event) != 0; };
@@ -3233,7 +3233,7 @@ void* QWebEngineUrlRequestJob_MetaObjectDefault(void* ptr)
 class MyQWebEngineUrlSchemeHandler: public QWebEngineUrlSchemeHandler
 {
 public:
-	MyQWebEngineUrlSchemeHandler(QObject *parent) : QWebEngineUrlSchemeHandler(parent) {};
+	MyQWebEngineUrlSchemeHandler(QObject *parent = Q_NULLPTR) : QWebEngineUrlSchemeHandler(parent) {};
 	void requestStarted(QWebEngineUrlRequestJob * request) { callbackQWebEngineUrlSchemeHandler_RequestStarted(this, request); };
 	bool event(QEvent * e) { return callbackQWebEngineUrlSchemeHandler_Event(this, e) != 0; };
 	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWebEngineUrlSchemeHandler_EventFilter(this, watched, event) != 0; };
@@ -3422,7 +3422,7 @@ void* QWebEngineUrlSchemeHandler_MetaObjectDefault(void* ptr)
 class MyQWebEngineView: public QWebEngineView
 {
 public:
-	MyQWebEngineView(QWidget *parent) : QWebEngineView(parent) {};
+	MyQWebEngineView(QWidget *parent = Q_NULLPTR) : QWebEngineView(parent) {};
 	QWebEngineView * createWindow(QWebEnginePage::WebWindowType ty) { return static_cast<QWebEngineView*>(callbackQWebEngineView_CreateWindow(this, ty)); };
 	bool event(QEvent * ev) { return callbackQWebEngineView_Event(this, ev) != 0; };
 	void back() { callbackQWebEngineView_Back(this); };

websockets/websockets.cpp

@@ -54,7 +54,7 @@
 class MyQMaskGenerator: public QMaskGenerator
 {
 public:
-	MyQMaskGenerator(QObject *parent) : QMaskGenerator(parent) {};
+	MyQMaskGenerator(QObject *parent = Q_NULLPTR) : QMaskGenerator(parent) {};
 	bool seed() { return callbackQMaskGenerator_Seed(this) != 0; };
 	quint32 nextMask() { return callbackQMaskGenerator_NextMask(this); };
 	 ~MyQMaskGenerator() { callbackQMaskGenerator_DestroyQMaskGenerator(this); };
@@ -255,7 +255,7 @@ void* QMaskGenerator_MetaObjectDefault(void* ptr)
 class MyQWebSocket: public QWebSocket
 {
 public:
-	MyQWebSocket(const QString &origin, QWebSocketProtocol::Version version, QObject *parent) : QWebSocket(origin, version, parent) {};
+	MyQWebSocket(const QString &origin = QString(), QWebSocketProtocol::Version version = QWebSocketProtocol::VersionLatest, QObject *parent = Q_NULLPTR) : QWebSocket(origin, version, parent) {};
 	void Signal_AboutToClose() { callbackQWebSocket_AboutToClose(this); };
 	void Signal_BinaryFrameReceived(const QByteArray & frame, bool isLastFrame) { callbackQWebSocket_BinaryFrameReceived(this, const_cast<QByteArray*>(&frame), isLastFrame); };
 	void Signal_BinaryMessageReceived(const QByteArray & message) { callbackQWebSocket_BinaryMessageReceived(this, const_cast<QByteArray*>(&message)); };
@@ -969,7 +969,7 @@ char QWebSocketCorsAuthenticator_Allowed(void* ptr)
 class MyQWebSocketServer: public QWebSocketServer
 {
 public:
-	MyQWebSocketServer(const QString &serverName, SslMode secureMode, QObject *parent) : QWebSocketServer(serverName, secureMode, parent) {};
+	MyQWebSocketServer(const QString &serverName, SslMode secureMode, QObject *parent = Q_NULLPTR) : QWebSocketServer(serverName, secureMode, parent) {};
 	QWebSocket * nextPendingConnection() { return static_cast<QWebSocket*>(callbackQWebSocketServer_NextPendingConnection(this)); };
 	void Signal_AcceptError(QAbstractSocket::SocketError socketError) { callbackQWebSocketServer_AcceptError(this, socketError); };
 	void Signal_Closed() { callbackQWebSocketServer_Closed(this); };

xmlpatterns/xmlpatterns.cpp

@@ -212,7 +212,7 @@ void* QAbstractMessageHandler_MetaObjectDefault(void* ptr)
 class MyQAbstractUriResolver: public QAbstractUriResolver
 {
 public:
-	MyQAbstractUriResolver(QObject *parent) : QAbstractUriResolver(parent) {};
+	MyQAbstractUriResolver(QObject *parent = Q_NULLPTR) : QAbstractUriResolver(parent) {};
 	 ~MyQAbstractUriResolver() { callbackQAbstractUriResolver_DestroyQAbstractUriResolver(this); };
 	QUrl resolve(const QUrl & relative, const QUrl & baseURI) const { return *static_cast<QUrl*>(callbackQAbstractUriResolver_Resolve(const_cast<void*>(static_cast<const void*>(this)), const_cast<QUrl*>(&relative), const_cast<QUrl*>(&baseURI))); };
 	bool event(QEvent * e) { return callbackQAbstractUriResolver_Event(this, e) != 0; };