code.ivysaur.me/miqt
1
0
Fork 0
mirror of https://github.com/mappu/miqt.git synced 2025-02-22 20:40:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

qt: rebuild (more const correctness, new connect handlers)

Browse Source
This commit is contained in:
mappu 2024-09-07 15:31:00 +12:00
parent d6d4afb4f2
commit 218db127fa
102 changed files with 798 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
qt/gen_qabstractbutton.cpp
View File

@ -177,6 +177,12 @@ void QAbstractButton_Clicked(QAbstractButton* self) {
self->clicked();
}
void QAbstractButton_connect_Clicked(QAbstractButton* self, void* slot) {
QAbstractButton::connect(self, static_cast<void (QAbstractButton::*)(bool)>(&QAbstractButton::clicked), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractButton_Toggled(QAbstractButton* self, bool checked) {
self->toggled(checked);
}

8
qt/gen_qabstractbutton.go
View File

@ -232,6 +232,14 @@ func (this *QAbstractButton) Clicked() {
C.QAbstractButton_Clicked(this.h)
}
func (this *QAbstractButton) OnClicked(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractButton_connect_Clicked(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractButton) Toggled(checked bool) {
C.QAbstractButton_Toggled(this.h, (C.bool)(checked))
}

1
qt/gen_qabstractbutton.h
View File

@ -61,6 +61,7 @@ void QAbstractButton_connect_Pressed(QAbstractButton* self, void* slot);
void QAbstractButton_Released(QAbstractButton* self);
void QAbstractButton_connect_Released(QAbstractButton* self, void* slot);
void QAbstractButton_Clicked(QAbstractButton* self);
void QAbstractButton_connect_Clicked(QAbstractButton* self, void* slot);
void QAbstractButton_Toggled(QAbstractButton* self, bool checked);
void QAbstractButton_connect_Toggled(QAbstractButton* self, void* slot);
void QAbstractButton_Tr2(const char* s, const char* c, char** _out, int* _out_Strlen);

6
qt/gen_qabstractitemdelegate.cpp
View File

@ -117,6 +117,12 @@ void QAbstractItemDelegate_CloseEditor(QAbstractItemDelegate* self, QWidget* edi
self->closeEditor(editor);
}
void QAbstractItemDelegate_connect_CloseEditor(QAbstractItemDelegate* self, void* slot) {
QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor) {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractItemDelegate_SizeHintChanged(QAbstractItemDelegate* self, QModelIndex* param1) {
self->sizeHintChanged(*param1);
}

8
qt/gen_qabstractitemdelegate.go
View File

@ -160,6 +160,14 @@ func (this *QAbstractItemDelegate) CloseEditor(editor *QWidget) {
C.QAbstractItemDelegate_CloseEditor(this.h, editor.cPointer())
}
func (this *QAbstractItemDelegate) OnCloseEditor(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemDelegate_connect_CloseEditor(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemDelegate) SizeHintChanged(param1 *QModelIndex) {
C.QAbstractItemDelegate_SizeHintChanged(this.h, param1.cPointer())
}

1
qt/gen_qabstractitemdelegate.h
View File

@ -56,6 +56,7 @@ void QAbstractItemDelegate_PaintingRoles(QAbstractItemDelegate* self, int** _out
void QAbstractItemDelegate_CommitData(QAbstractItemDelegate* self, QWidget* editor);
void QAbstractItemDelegate_connect_CommitData(QAbstractItemDelegate* self, void* slot);
void QAbstractItemDelegate_CloseEditor(QAbstractItemDelegate* self, QWidget* editor);
void QAbstractItemDelegate_connect_CloseEditor(QAbstractItemDelegate* self, void* slot);
void QAbstractItemDelegate_SizeHintChanged(QAbstractItemDelegate* self, QModelIndex* param1);
void QAbstractItemDelegate_connect_SizeHintChanged(QAbstractItemDelegate* self, void* slot);
void QAbstractItemDelegate_Tr2(const char* s, const char* c, char** _out, int* _out_Strlen);

60
qt/gen_qabstractitemmodel.cpp
View File

@ -102,7 +102,7 @@ bool QModelIndex_OperatorLesser(QModelIndex* self, QModelIndex* other) {
}
QVariant* QModelIndex_Data1(QModelIndex* self, int role) {
QVariant ret = self->data(static_cast<int>(role));
QVariant ret = const_cast<const QModelIndex*>(self)->data(static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -206,7 +206,7 @@ bool QPersistentModelIndex_IsValid(QPersistentModelIndex* self) {
}
QVariant* QPersistentModelIndex_Data1(QPersistentModelIndex* self, int role) {
QVariant ret = self->data(static_cast<int>(role));
QVariant ret = const_cast<const QPersistentModelIndex*>(self)->data(static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -431,6 +431,12 @@ void QAbstractItemModel_DataChanged(QAbstractItemModel* self, QModelIndex* topLe
self->dataChanged(*topLeft, *bottomRight);
}
void QAbstractItemModel_connect_DataChanged(QAbstractItemModel* self, void* slot) {
QAbstractItemModel::connect(self, static_cast<void (QAbstractItemModel::*)(const QModelIndex&, const QModelIndex&, const QVector<int>&)>(&QAbstractItemModel::dataChanged), self, [=](const QModelIndex& topLeft, const QModelIndex& bottomRight) {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractItemModel_HeaderDataChanged(QAbstractItemModel* self, uintptr_t orientation, int first, int last) {
self->headerDataChanged(static_cast<Qt::Orientation>(orientation), static_cast<int>(first), static_cast<int>(last));
}
@ -445,10 +451,22 @@ void QAbstractItemModel_LayoutChanged(QAbstractItemModel* self) {
self->layoutChanged();
}
void QAbstractItemModel_connect_LayoutChanged(QAbstractItemModel* self, void* slot) {
QAbstractItemModel::connect(self, static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractItemModel_LayoutAboutToBeChanged(QAbstractItemModel* self) {
self->layoutAboutToBeChanged();
}
void QAbstractItemModel_connect_LayoutAboutToBeChanged(QAbstractItemModel* self, void* slot) {
QAbstractItemModel::connect(self, static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
bool QAbstractItemModel_Submit(QAbstractItemModel* self) {
return self->submit();
}
@ -494,29 +512,29 @@ void QAbstractItemModel_TrUtf83(const char* s, const char* c, int n, char** _out
}
bool QAbstractItemModel_HasIndex3(QAbstractItemModel* self, int row, int column, QModelIndex* parent) {
return self->hasIndex(static_cast<int>(row), static_cast<int>(column), *parent);
return const_cast<const QAbstractItemModel*>(self)->hasIndex(static_cast<int>(row), static_cast<int>(column), *parent);
}
QModelIndex* QAbstractItemModel_Index3(QAbstractItemModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QAbstractItemModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QAbstractItemModel_RowCount1(QAbstractItemModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QAbstractItemModel*>(self)->rowCount(*parent);
}
int QAbstractItemModel_ColumnCount1(QAbstractItemModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QAbstractItemModel*>(self)->columnCount(*parent);
}
bool QAbstractItemModel_HasChildren1(QAbstractItemModel* self, QModelIndex* parent) {
return self->hasChildren(*parent);
return const_cast<const QAbstractItemModel*>(self)->hasChildren(*parent);
}
QVariant* QAbstractItemModel_Data2(QAbstractItemModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QAbstractItemModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -526,7 +544,7 @@ bool QAbstractItemModel_SetData3(QAbstractItemModel* self, QModelIndex* index, Q
}
QVariant* QAbstractItemModel_HeaderData3(QAbstractItemModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QAbstractItemModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -572,7 +590,7 @@ void QAbstractItemModel_Sort2(QAbstractItemModel* self, int column, uintptr_t or
}
void QAbstractItemModel_Match4(QAbstractItemModel* self, QModelIndex* start, int role, QVariant* value, int hits, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
QModelIndexList ret = const_cast<const QAbstractItemModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -583,7 +601,7 @@ void QAbstractItemModel_Match4(QAbstractItemModel* self, QModelIndex* start, int
}
void QAbstractItemModel_Match5(QAbstractItemModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
QModelIndexList ret = const_cast<const QAbstractItemModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -594,7 +612,7 @@ void QAbstractItemModel_Match5(QAbstractItemModel* self, QModelIndex* start, int
}
bool QAbstractItemModel_CheckIndex2(QAbstractItemModel* self, QModelIndex* index, int options) {
return self->checkIndex(*index, static_cast<QAbstractItemModel::CheckIndexOptions>(options));
return const_cast<const QAbstractItemModel*>(self)->checkIndex(*index, static_cast<QAbstractItemModel::CheckIndexOptions>(options));
}
void QAbstractItemModel_DataChanged3(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight, int* roles, size_t roles_len) {
@ -621,6 +639,12 @@ void QAbstractItemModel_LayoutChanged1(QAbstractItemModel* self, QPersistentMode
self->layoutChanged(parents_QList);
}
void QAbstractItemModel_connect_LayoutChanged1(QAbstractItemModel* self, void* slot) {
QAbstractItemModel::connect(self, static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=](const QList<QPersistentModelIndex>& parents) {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractItemModel_LayoutChanged2(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len, uintptr_t hint) {
QList<QPersistentModelIndex> parents_QList;
parents_QList.reserve(parents_len);
@ -645,6 +669,12 @@ void QAbstractItemModel_LayoutAboutToBeChanged1(QAbstractItemModel* self, QPersi
self->layoutAboutToBeChanged(parents_QList);
}
void QAbstractItemModel_connect_LayoutAboutToBeChanged1(QAbstractItemModel* self, void* slot) {
QAbstractItemModel::connect(self, static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=](const QList<QPersistentModelIndex>& parents) {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractItemModel_LayoutAboutToBeChanged2(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len, uintptr_t hint) {
QList<QPersistentModelIndex> parents_QList;
parents_QList.reserve(parents_len);
@ -744,7 +774,7 @@ void QAbstractTableModel_TrUtf83(const char* s, const char* c, int n, char** _ou
}
QModelIndex* QAbstractTableModel_Index3(QAbstractTableModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QAbstractTableModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
@ -833,13 +863,13 @@ void QAbstractListModel_TrUtf83(const char* s, const char* c, int n, char** _out
}
QModelIndex* QAbstractListModel_Index2(QAbstractListModel* self, int row, int column) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column));
QModelIndex ret = const_cast<const QAbstractListModel*>(self)->index(static_cast<int>(row), static_cast<int>(column));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
QModelIndex* QAbstractListModel_Index3(QAbstractListModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QAbstractListModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}

40
qt/gen_qabstractitemmodel.go
View File

@ -660,6 +660,14 @@ func (this *QAbstractItemModel) DataChanged(topLeft *QModelIndex, bottomRight *Q
C.QAbstractItemModel_DataChanged(this.h, topLeft.cPointer(), bottomRight.cPointer())
}
func (this *QAbstractItemModel) OnDataChanged(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemModel_connect_DataChanged(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemModel) HeaderDataChanged(orientation Orientation, first int, last int) {
C.QAbstractItemModel_HeaderDataChanged(this.h, (C.uintptr_t)(orientation), (C.int)(first), (C.int)(last))
}
@ -676,10 +684,26 @@ func (this *QAbstractItemModel) LayoutChanged() {
C.QAbstractItemModel_LayoutChanged(this.h)
}
func (this *QAbstractItemModel) OnLayoutChanged(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemModel_connect_LayoutChanged(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemModel) LayoutAboutToBeChanged() {
C.QAbstractItemModel_LayoutAboutToBeChanged(this.h)
}
func (this *QAbstractItemModel) OnLayoutAboutToBeChanged(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemModel_connect_LayoutAboutToBeChanged(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemModel) Submit() bool {
ret := C.QAbstractItemModel_Submit(this.h)
return (bool)(ret)
@ -907,6 +931,14 @@ func (this *QAbstractItemModel) LayoutChanged1(parents []QPersistentModelIndex)
C.QAbstractItemModel_LayoutChanged1(this.h, &parents_CArray[0], C.size_t(len(parents)))
}
func (this *QAbstractItemModel) OnLayoutChanged1(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemModel_connect_LayoutChanged1(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemModel) LayoutChanged2(parents []QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
// For the C ABI, malloc a C array of raw pointers
parents_CArray := (*[0xffff]*C.QPersistentModelIndex)(C.malloc(C.size_t(8 * len(parents))))
@ -935,6 +967,14 @@ func (this *QAbstractItemModel) LayoutAboutToBeChanged1(parents []QPersistentMod
C.QAbstractItemModel_LayoutAboutToBeChanged1(this.h, &parents_CArray[0], C.size_t(len(parents)))
}
func (this *QAbstractItemModel) OnLayoutAboutToBeChanged1(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractItemModel_connect_LayoutAboutToBeChanged1(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractItemModel) LayoutAboutToBeChanged2(parents []QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
// For the C ABI, malloc a C array of raw pointers
parents_CArray := (*[0xffff]*C.QPersistentModelIndex)(C.malloc(C.size_t(8 * len(parents))))

5
qt/gen_qabstractitemmodel.h
View File

@ -118,10 +118,13 @@ void QAbstractItemModel_Match(QAbstractItemModel* self, QModelIndex* start, int
QSize* QAbstractItemModel_Span(QAbstractItemModel* self, QModelIndex* index);
bool QAbstractItemModel_CheckIndex(QAbstractItemModel* self, QModelIndex* index);
void QAbstractItemModel_DataChanged(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight);
void QAbstractItemModel_connect_DataChanged(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_HeaderDataChanged(QAbstractItemModel* self, uintptr_t orientation, int first, int last);
void QAbstractItemModel_connect_HeaderDataChanged(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutChanged(QAbstractItemModel* self);
void QAbstractItemModel_connect_LayoutChanged(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutAboutToBeChanged(QAbstractItemModel* self);
void QAbstractItemModel_connect_LayoutAboutToBeChanged(QAbstractItemModel* self, void* slot);
bool QAbstractItemModel_Submit(QAbstractItemModel* self);
void QAbstractItemModel_Revert(QAbstractItemModel* self);
void QAbstractItemModel_Tr2(const char* s, const char* c, char** _out, int* _out_Strlen);
@ -152,9 +155,11 @@ bool QAbstractItemModel_CheckIndex2(QAbstractItemModel* self, QModelIndex* index
void QAbstractItemModel_DataChanged3(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight, int* roles, size_t roles_len);
void QAbstractItemModel_connect_DataChanged3(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutChanged1(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len);
void QAbstractItemModel_connect_LayoutChanged1(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutChanged2(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len, uintptr_t hint);
void QAbstractItemModel_connect_LayoutChanged2(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutAboutToBeChanged1(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len);
void QAbstractItemModel_connect_LayoutAboutToBeChanged1(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_LayoutAboutToBeChanged2(QAbstractItemModel* self, QPersistentModelIndex** parents, size_t parents_len, uintptr_t hint);
void QAbstractItemModel_connect_LayoutAboutToBeChanged2(QAbstractItemModel* self, void* slot);
void QAbstractItemModel_Delete(QAbstractItemModel* self);

6
qt/gen_qabstractproxymodel.cpp
View File

@ -207,13 +207,13 @@ void QAbstractProxyModel_TrUtf83(const char* s, const char* c, int n, char** _ou
}
QVariant* QAbstractProxyModel_Data2(QAbstractProxyModel* self, QModelIndex* proxyIndex, int role) {
QVariant ret = self->data(*proxyIndex, static_cast<int>(role));
QVariant ret = const_cast<const QAbstractProxyModel*>(self)->data(*proxyIndex, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
QVariant* QAbstractProxyModel_HeaderData3(QAbstractProxyModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QAbstractProxyModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -231,7 +231,7 @@ void QAbstractProxyModel_Sort2(QAbstractProxyModel* self, int column, uintptr_t
}
bool QAbstractProxyModel_HasChildren1(QAbstractProxyModel* self, QModelIndex* parent) {
return self->hasChildren(*parent);
return const_cast<const QAbstractProxyModel*>(self)->hasChildren(*parent);
}
void QAbstractProxyModel_Delete(QAbstractProxyModel* self) {

6
qt/gen_qabstracttextdocumentlayout.cpp
View File

@ -130,6 +130,12 @@ void QAbstractTextDocumentLayout_Update(QAbstractTextDocumentLayout* self) {
self->update();
}
void QAbstractTextDocumentLayout_connect_Update(QAbstractTextDocumentLayout* self, void* slot) {
QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF&)>(&QAbstractTextDocumentLayout::update), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAbstractTextDocumentLayout_UpdateBlock(QAbstractTextDocumentLayout* self, QTextBlock* block) {
self->updateBlock(*block);
}

8
qt/gen_qabstracttextdocumentlayout.go
View File

@ -177,6 +177,14 @@ func (this *QAbstractTextDocumentLayout) Update() {
C.QAbstractTextDocumentLayout_Update(this.h)
}
func (this *QAbstractTextDocumentLayout) OnUpdate(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAbstractTextDocumentLayout_connect_Update(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAbstractTextDocumentLayout) UpdateBlock(block *QTextBlock) {
C.QAbstractTextDocumentLayout_UpdateBlock(this.h, block.cPointer())
}

1
qt/gen_qabstracttextdocumentlayout.h
View File

@ -72,6 +72,7 @@ QTextDocument* QAbstractTextDocumentLayout_Document(QAbstractTextDocumentLayout*
void QAbstractTextDocumentLayout_RegisterHandler(QAbstractTextDocumentLayout* self, int objectType, QObject* component);
void QAbstractTextDocumentLayout_UnregisterHandler(QAbstractTextDocumentLayout* self, int objectType);
void QAbstractTextDocumentLayout_Update(QAbstractTextDocumentLayout* self);
void QAbstractTextDocumentLayout_connect_Update(QAbstractTextDocumentLayout* self, void* slot);
void QAbstractTextDocumentLayout_UpdateBlock(QAbstractTextDocumentLayout* self, QTextBlock* block);
void QAbstractTextDocumentLayout_connect_UpdateBlock(QAbstractTextDocumentLayout* self, void* slot);
void QAbstractTextDocumentLayout_DocumentSizeChanged(QAbstractTextDocumentLayout* self, QSizeF* newSize);

6
qt/gen_qaction.cpp
View File

@ -376,6 +376,12 @@ void QAction_Triggered(QAction* self) {
self->triggered();
}
void QAction_connect_Triggered(QAction* self, void* slot) {
QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::triggered), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QAction_Hovered(QAction* self) {
self->hovered();
}

8
qt/gen_qaction.go
View File

@ -486,6 +486,14 @@ func (this *QAction) Triggered() {
C.QAction_Triggered(this.h)
}
func (this *QAction) OnTriggered(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QAction_connect_Triggered(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QAction) Hovered() {
C.QAction_Hovered(this.h)
}

1
qt/gen_qaction.h
View File

@ -105,6 +105,7 @@ void QAction_SetVisible(QAction* self, bool visible);
void QAction_Changed(QAction* self);
void QAction_connect_Changed(QAction* self, void* slot);
void QAction_Triggered(QAction* self);
void QAction_connect_Triggered(QAction* self, void* slot);
void QAction_Hovered(QAction* self);
void QAction_connect_Hovered(QAction* self, void* slot);
void QAction_Toggled(QAction* self, bool param1);

104
qt/gen_qbytearray.cpp
View File

@ -697,14 +697,14 @@ QByteArray* QByteArray_SetNumWithUint(QByteArray* self, unsigned int param1) {
return &ret;
}
QByteArray* QByteArray_SetNumWithQlonglong(QByteArray* self, int64_t param1) {
QByteArray& ret = self->setNum((qlonglong)(param1));
QByteArray* QByteArray_SetNumWithQlonglong(QByteArray* self, long long param1) {
QByteArray& ret = self->setNum(static_cast<qint64>(param1));
// Cast returned reference into pointer
return &ret;
}
QByteArray* QByteArray_SetNumWithQulonglong(QByteArray* self, uint64_t param1) {
QByteArray& ret = self->setNum((qulonglong)(param1));
QByteArray* QByteArray_SetNumWithQulonglong(QByteArray* self, unsigned long long param1) {
QByteArray& ret = self->setNum(static_cast<quint64>(param1));
// Cast returned reference into pointer
return &ret;
}
@ -739,14 +739,14 @@ QByteArray* QByteArray_NumberWithUint(unsigned int param1) {
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_NumberWithQlonglong(int64_t param1) {
QByteArray ret = QByteArray::number((qlonglong)(param1));
QByteArray* QByteArray_NumberWithQlonglong(long long param1) {
QByteArray ret = QByteArray::number(static_cast<qint64>(param1));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_NumberWithQulonglong(uint64_t param1) {
QByteArray ret = QByteArray::number((qulonglong)(param1));
QByteArray* QByteArray_NumberWithQulonglong(unsigned long long param1) {
QByteArray ret = QByteArray::number(static_cast<quint64>(param1));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
@ -872,163 +872,163 @@ QByteArray* QByteArray_Fill2(QByteArray* self, char c, int size) {
}
int QByteArray_IndexOf2(QByteArray* self, char c, int from) {
return self->indexOf(static_cast<char>(c), static_cast<int>(from));
return const_cast<const QByteArray*>(self)->indexOf(static_cast<char>(c), static_cast<int>(from));
}
int QByteArray_IndexOf22(QByteArray* self, const char* c, int from) {
return self->indexOf(c, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->indexOf(c, static_cast<int>(from));
}
int QByteArray_IndexOf23(QByteArray* self, QByteArray* a, int from) {
return self->indexOf(*a, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->indexOf(*a, static_cast<int>(from));
}
int QByteArray_LastIndexOf2(QByteArray* self, char c, int from) {
return self->lastIndexOf(static_cast<char>(c), static_cast<int>(from));
return const_cast<const QByteArray*>(self)->lastIndexOf(static_cast<char>(c), static_cast<int>(from));
}
int QByteArray_LastIndexOf22(QByteArray* self, const char* c, int from) {
return self->lastIndexOf(c, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->lastIndexOf(c, static_cast<int>(from));
}
int QByteArray_LastIndexOf23(QByteArray* self, QByteArray* a, int from) {
return self->lastIndexOf(*a, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->lastIndexOf(*a, static_cast<int>(from));
}
int QByteArray_Compare2(QByteArray* self, const char* c, uintptr_t cs) {
return self->compare(c, static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QByteArray*>(self)->compare(c, static_cast<Qt::CaseSensitivity>(cs));
}
int QByteArray_Compare22(QByteArray* self, QByteArray* a, uintptr_t cs) {
return self->compare(*a, static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QByteArray*>(self)->compare(*a, static_cast<Qt::CaseSensitivity>(cs));
}
QByteArray* QByteArray_Mid2(QByteArray* self, int index, int lenVal) {
QByteArray ret = self->mid(static_cast<int>(index), static_cast<int>(lenVal));
QByteArray ret = const_cast<const QByteArray*>(self)->mid(static_cast<int>(index), static_cast<int>(lenVal));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_LeftJustified2(QByteArray* self, int width, char fill) {
QByteArray ret = self->leftJustified(static_cast<int>(width), static_cast<char>(fill));
QByteArray ret = const_cast<const QByteArray*>(self)->leftJustified(static_cast<int>(width), static_cast<char>(fill));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_LeftJustified3(QByteArray* self, int width, char fill, bool truncate) {
QByteArray ret = self->leftJustified(static_cast<int>(width), static_cast<char>(fill), truncate);
QByteArray ret = const_cast<const QByteArray*>(self)->leftJustified(static_cast<int>(width), static_cast<char>(fill), truncate);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_RightJustified2(QByteArray* self, int width, char fill) {
QByteArray ret = self->rightJustified(static_cast<int>(width), static_cast<char>(fill));
QByteArray ret = const_cast<const QByteArray*>(self)->rightJustified(static_cast<int>(width), static_cast<char>(fill));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_RightJustified3(QByteArray* self, int width, char fill, bool truncate) {
QByteArray ret = self->rightJustified(static_cast<int>(width), static_cast<char>(fill), truncate);
QByteArray ret = const_cast<const QByteArray*>(self)->rightJustified(static_cast<int>(width), static_cast<char>(fill), truncate);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
int QByteArray_IndexOf24(QByteArray* self, const char* s, size_t s_Strlen, int from) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->indexOf(s_QString, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->indexOf(s_QString, static_cast<int>(from));
}
int QByteArray_LastIndexOf24(QByteArray* self, const char* s, size_t s_Strlen, int from) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->lastIndexOf(s_QString, static_cast<int>(from));
return const_cast<const QByteArray*>(self)->lastIndexOf(s_QString, static_cast<int>(from));
}
int16_t QByteArray_ToShort1(QByteArray* self, bool* ok) {
return self->toShort(ok);
return const_cast<const QByteArray*>(self)->toShort(ok);
}
int16_t QByteArray_ToShort2(QByteArray* self, bool* ok, int base) {
return self->toShort(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toShort(ok, static_cast<int>(base));
}
uint16_t QByteArray_ToUShort1(QByteArray* self, bool* ok) {
return self->toUShort(ok);
return const_cast<const QByteArray*>(self)->toUShort(ok);
}
uint16_t QByteArray_ToUShort2(QByteArray* self, bool* ok, int base) {
return self->toUShort(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toUShort(ok, static_cast<int>(base));
}
int QByteArray_ToInt1(QByteArray* self, bool* ok) {
return self->toInt(ok);
return const_cast<const QByteArray*>(self)->toInt(ok);
}
int QByteArray_ToInt2(QByteArray* self, bool* ok, int base) {
return self->toInt(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toInt(ok, static_cast<int>(base));
}
unsigned int QByteArray_ToUInt1(QByteArray* self, bool* ok) {
return self->toUInt(ok);
return const_cast<const QByteArray*>(self)->toUInt(ok);
}
unsigned int QByteArray_ToUInt2(QByteArray* self, bool* ok, int base) {
return self->toUInt(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toUInt(ok, static_cast<int>(base));
}
long QByteArray_ToLong1(QByteArray* self, bool* ok) {
return self->toLong(ok);
return const_cast<const QByteArray*>(self)->toLong(ok);
}
long QByteArray_ToLong2(QByteArray* self, bool* ok, int base) {
return self->toLong(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toLong(ok, static_cast<int>(base));
}
unsigned long QByteArray_ToULong1(QByteArray* self, bool* ok) {
return self->toULong(ok);
return const_cast<const QByteArray*>(self)->toULong(ok);
}
unsigned long QByteArray_ToULong2(QByteArray* self, bool* ok, int base) {
return self->toULong(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toULong(ok, static_cast<int>(base));
}
int64_t QByteArray_ToLongLong1(QByteArray* self, bool* ok) {
return self->toLongLong(ok);
return const_cast<const QByteArray*>(self)->toLongLong(ok);
}
int64_t QByteArray_ToLongLong2(QByteArray* self, bool* ok, int base) {
return self->toLongLong(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toLongLong(ok, static_cast<int>(base));
}
uint64_t QByteArray_ToULongLong1(QByteArray* self, bool* ok) {
return self->toULongLong(ok);
return const_cast<const QByteArray*>(self)->toULongLong(ok);
}
uint64_t QByteArray_ToULongLong2(QByteArray* self, bool* ok, int base) {
return self->toULongLong(ok, static_cast<int>(base));
return const_cast<const QByteArray*>(self)->toULongLong(ok, static_cast<int>(base));
}
float QByteArray_ToFloat1(QByteArray* self, bool* ok) {
return self->toFloat(ok);
return const_cast<const QByteArray*>(self)->toFloat(ok);
}
double QByteArray_ToDouble1(QByteArray* self, bool* ok) {
return self->toDouble(ok);
return const_cast<const QByteArray*>(self)->toDouble(ok);
}
QByteArray* QByteArray_ToPercentEncoding1(QByteArray* self, QByteArray* exclude) {
QByteArray ret = self->toPercentEncoding(*exclude);
QByteArray ret = const_cast<const QByteArray*>(self)->toPercentEncoding(*exclude);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_ToPercentEncoding2(QByteArray* self, QByteArray* exclude, QByteArray* include) {
QByteArray ret = self->toPercentEncoding(*exclude, *include);
QByteArray ret = const_cast<const QByteArray*>(self)->toPercentEncoding(*exclude, *include);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_ToPercentEncoding3(QByteArray* self, QByteArray* exclude, QByteArray* include, char percent) {
QByteArray ret = self->toPercentEncoding(*exclude, *include, static_cast<char>(percent));
QByteArray ret = const_cast<const QByteArray*>(self)->toPercentEncoding(*exclude, *include, static_cast<char>(percent));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
@ -1057,14 +1057,14 @@ QByteArray* QByteArray_SetNum24(QByteArray* self, unsigned int param1, int base)
return &ret;
}
QByteArray* QByteArray_SetNum25(QByteArray* self, int64_t param1, int base) {
QByteArray& ret = self->setNum((qlonglong)(param1), static_cast<int>(base));
QByteArray* QByteArray_SetNum25(QByteArray* self, long long param1, int base) {
QByteArray& ret = self->setNum(static_cast<qint64>(param1), static_cast<int>(base));
// Cast returned reference into pointer
return &ret;
}
QByteArray* QByteArray_SetNum26(QByteArray* self, uint64_t param1, int base) {
QByteArray& ret = self->setNum((qulonglong)(param1), static_cast<int>(base));
QByteArray* QByteArray_SetNum26(QByteArray* self, unsigned long long param1, int base) {
QByteArray& ret = self->setNum(static_cast<quint64>(param1), static_cast<int>(base));
// Cast returned reference into pointer
return &ret;
}
@ -1105,14 +1105,14 @@ QByteArray* QByteArray_Number22(unsigned int param1, int base) {
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_Number23(int64_t param1, int base) {
QByteArray ret = QByteArray::number((qlonglong)(param1), static_cast<int>(base));
QByteArray* QByteArray_Number23(long long param1, int base) {
QByteArray ret = QByteArray::number(static_cast<qint64>(param1), static_cast<int>(base));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QByteArray* QByteArray_Number24(uint64_t param1, int base) {
QByteArray ret = QByteArray::number((qulonglong)(param1), static_cast<int>(base));
QByteArray* QByteArray_Number24(unsigned long long param1, int base) {
QByteArray ret = QByteArray::number(static_cast<quint64>(param1), static_cast<int>(base));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}

16
qt/gen_qbytearray.go
View File

@ -975,12 +975,12 @@ func (this *QByteArray) SetNumWithUint(param1 uint) *QByteArray {
}
func (this *QByteArray) SetNumWithQlonglong(param1 int64) *QByteArray {
ret := C.QByteArray_SetNumWithQlonglong(this.h, (C.int64_t)(param1))
ret := C.QByteArray_SetNumWithQlonglong(this.h, (C.longlong)(param1))
return newQByteArray_U(unsafe.Pointer(ret))
}
func (this *QByteArray) SetNumWithQulonglong(param1 uint64) *QByteArray {
ret := C.QByteArray_SetNumWithQulonglong(this.h, (C.uint64_t)(param1))
ret := C.QByteArray_SetNumWithQulonglong(this.h, (C.ulonglong)(param1))
return newQByteArray_U(unsafe.Pointer(ret))
}
@ -1024,7 +1024,7 @@ func QByteArray_NumberWithUint(param1 uint) *QByteArray {
}
func QByteArray_NumberWithQlonglong(param1 int64) *QByteArray {
ret := C.QByteArray_NumberWithQlonglong((C.int64_t)(param1))
ret := C.QByteArray_NumberWithQlonglong((C.longlong)(param1))
// Qt uses pass-by-value semantics for this type. Mimic with finalizer
ret1 := newQByteArray(ret)
runtime.SetFinalizer(ret1, func(ret2 *QByteArray) {
@ -1035,7 +1035,7 @@ func QByteArray_NumberWithQlonglong(param1 int64) *QByteArray {
}
func QByteArray_NumberWithQulonglong(param1 uint64) *QByteArray {
ret := C.QByteArray_NumberWithQulonglong((C.uint64_t)(param1))
ret := C.QByteArray_NumberWithQulonglong((C.ulonglong)(param1))
// Qt uses pass-by-value semantics for this type. Mimic with finalizer
ret1 := newQByteArray(ret)
runtime.SetFinalizer(ret1, func(ret2 *QByteArray) {
@ -1475,12 +1475,12 @@ func (this *QByteArray) SetNum24(param1 uint, base int) *QByteArray {
}
func (this *QByteArray) SetNum25(param1 int64, base int) *QByteArray {
ret := C.QByteArray_SetNum25(this.h, (C.int64_t)(param1), (C.int)(base))
ret := C.QByteArray_SetNum25(this.h, (C.longlong)(param1), (C.int)(base))
return newQByteArray_U(unsafe.Pointer(ret))
}
func (this *QByteArray) SetNum26(param1 uint64, base int) *QByteArray {
ret := C.QByteArray_SetNum26(this.h, (C.uint64_t)(param1), (C.int)(base))
ret := C.QByteArray_SetNum26(this.h, (C.ulonglong)(param1), (C.int)(base))
return newQByteArray_U(unsafe.Pointer(ret))
}
@ -1527,7 +1527,7 @@ func QByteArray_Number22(param1 uint, base int) *QByteArray {
}
func QByteArray_Number23(param1 int64, base int) *QByteArray {
ret := C.QByteArray_Number23((C.int64_t)(param1), (C.int)(base))
ret := C.QByteArray_Number23((C.longlong)(param1), (C.int)(base))
// Qt uses pass-by-value semantics for this type. Mimic with finalizer
ret1 := newQByteArray(ret)
runtime.SetFinalizer(ret1, func(ret2 *QByteArray) {
@ -1538,7 +1538,7 @@ func QByteArray_Number23(param1 int64, base int) *QByteArray {
}
func QByteArray_Number24(param1 uint64, base int) *QByteArray {
ret := C.QByteArray_Number24((C.uint64_t)(param1), (C.int)(base))
ret := C.QByteArray_Number24((C.ulonglong)(param1), (C.int)(base))
// Qt uses pass-by-value semantics for this type. Mimic with finalizer
ret1 := newQByteArray(ret)
runtime.SetFinalizer(ret1, func(ret2 *QByteArray) {

16
qt/gen_qbytearray.h
View File

@ -163,15 +163,15 @@ QByteArray* QByteArray_SetNum(QByteArray* self, int16_t param1);
QByteArray* QByteArray_SetNumWithUshort(QByteArray* self, uint16_t param1);
QByteArray* QByteArray_SetNumWithInt(QByteArray* self, int param1);
QByteArray* QByteArray_SetNumWithUint(QByteArray* self, unsigned int param1);
QByteArray* QByteArray_SetNumWithQlonglong(QByteArray* self, int64_t param1);
QByteArray* QByteArray_SetNumWithQulonglong(QByteArray* self, uint64_t param1);
QByteArray* QByteArray_SetNumWithQlonglong(QByteArray* self, long long param1);
QByteArray* QByteArray_SetNumWithQulonglong(QByteArray* self, unsigned long long param1);
QByteArray* QByteArray_SetNumWithFloat(QByteArray* self, float param1);
QByteArray* QByteArray_SetNumWithDouble(QByteArray* self, double param1);
QByteArray* QByteArray_SetRawData(QByteArray* self, const char* a, unsigned int n);
QByteArray* QByteArray_Number(int param1);
QByteArray* QByteArray_NumberWithUint(unsigned int param1);
QByteArray* QByteArray_NumberWithQlonglong(int64_t param1);
QByteArray* QByteArray_NumberWithQulonglong(uint64_t param1);
QByteArray* QByteArray_NumberWithQlonglong(long long param1);
QByteArray* QByteArray_NumberWithQulonglong(unsigned long long param1);
QByteArray* QByteArray_NumberWithDouble(double param1);
QByteArray* QByteArray_FromRawData(const char* param1, int size);
QByteArray__FromBase64Result* QByteArray_FromBase64Encoding(QByteArray* base64);
@ -238,16 +238,16 @@ QByteArray* QByteArray_SetNum2(QByteArray* self, int16_t param1, int base);
QByteArray* QByteArray_SetNum22(QByteArray* self, uint16_t param1, int base);
QByteArray* QByteArray_SetNum23(QByteArray* self, int param1, int base);
QByteArray* QByteArray_SetNum24(QByteArray* self, unsigned int param1, int base);
QByteArray* QByteArray_SetNum25(QByteArray* self, int64_t param1, int base);
QByteArray* QByteArray_SetNum26(QByteArray* self, uint64_t param1, int base);
QByteArray* QByteArray_SetNum25(QByteArray* self, long long param1, int base);
QByteArray* QByteArray_SetNum26(QByteArray* self, unsigned long long param1, int base);
QByteArray* QByteArray_SetNum27(QByteArray* self, float param1, char f);
QByteArray* QByteArray_SetNum3(QByteArray* self, float param1, char f, int prec);
QByteArray* QByteArray_SetNum28(QByteArray* self, double param1, char f);
QByteArray* QByteArray_SetNum32(QByteArray* self, double param1, char f, int prec);
QByteArray* QByteArray_Number2(int param1, int base);
QByteArray* QByteArray_Number22(unsigned int param1, int base);
QByteArray* QByteArray_Number23(int64_t param1, int base);
QByteArray* QByteArray_Number24(uint64_t param1, int base);
QByteArray* QByteArray_Number23(long long param1, int base);
QByteArray* QByteArray_Number24(unsigned long long param1, int base);
QByteArray* QByteArray_Number25(double param1, char f);
QByteArray* QByteArray_Number3(double param1, char f, int prec);
QByteArray__FromBase64Result* QByteArray_FromBase64Encoding2(QByteArray* base64, int options);

4
qt/gen_qbytearraymatcher.cpp
View File

@ -48,11 +48,11 @@ QByteArray* QByteArrayMatcher_Pattern(QByteArrayMatcher* self) {
}
int QByteArrayMatcher_IndexIn22(QByteArrayMatcher* self, QByteArray* ba, int from) {
return self->indexIn(*ba, static_cast<int>(from));
return const_cast<const QByteArrayMatcher*>(self)->indexIn(*ba, static_cast<int>(from));
}
int QByteArrayMatcher_IndexIn3(QByteArrayMatcher* self, const char* str, int lenVal, int from) {
return self->indexIn(str, static_cast<int>(lenVal), static_cast<int>(from));
return const_cast<const QByteArrayMatcher*>(self)->indexIn(str, static_cast<int>(lenVal), static_cast<int>(from));
}
void QByteArrayMatcher_Delete(QByteArrayMatcher* self) {

14
qt/gen_qcalendar.cpp
View File

@ -167,11 +167,11 @@ void QCalendar_AvailableCalendars(char*** _out, int** _out_Lengths, size_t* _out
}
int QCalendar_DaysInMonth2(QCalendar* self, int month, int year) {
return self->daysInMonth(static_cast<int>(month), static_cast<int>(year));
return const_cast<const QCalendar*>(self)->daysInMonth(static_cast<int>(month), static_cast<int>(year));
}
void QCalendar_MonthName3(QCalendar* self, QLocale* locale, int month, int year, char** _out, int* _out_Strlen) {
QString ret = self->monthName(*locale, static_cast<int>(month), static_cast<int>(year));
QString ret = const_cast<const QCalendar*>(self)->monthName(*locale, static_cast<int>(month), static_cast<int>(year));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -180,7 +180,7 @@ void QCalendar_MonthName3(QCalendar* self, QLocale* locale, int month, int year,
}
void QCalendar_MonthName4(QCalendar* self, QLocale* locale, int month, int year, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->monthName(*locale, static_cast<int>(month), static_cast<int>(year), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QCalendar*>(self)->monthName(*locale, static_cast<int>(month), static_cast<int>(year), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -189,7 +189,7 @@ void QCalendar_MonthName4(QCalendar* self, QLocale* locale, int month, int year,
}
void QCalendar_StandaloneMonthName3(QCalendar* self, QLocale* locale, int month, int year, char** _out, int* _out_Strlen) {
QString ret = self->standaloneMonthName(*locale, static_cast<int>(month), static_cast<int>(year));
QString ret = const_cast<const QCalendar*>(self)->standaloneMonthName(*locale, static_cast<int>(month), static_cast<int>(year));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -198,7 +198,7 @@ void QCalendar_StandaloneMonthName3(QCalendar* self, QLocale* locale, int month,
}
void QCalendar_StandaloneMonthName4(QCalendar* self, QLocale* locale, int month, int year, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->standaloneMonthName(*locale, static_cast<int>(month), static_cast<int>(year), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QCalendar*>(self)->standaloneMonthName(*locale, static_cast<int>(month), static_cast<int>(year), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -207,7 +207,7 @@ void QCalendar_StandaloneMonthName4(QCalendar* self, QLocale* locale, int month,
}
void QCalendar_WeekDayName3(QCalendar* self, QLocale* locale, int day, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->weekDayName(*locale, static_cast<int>(day), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QCalendar*>(self)->weekDayName(*locale, static_cast<int>(day), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -216,7 +216,7 @@ void QCalendar_WeekDayName3(QCalendar* self, QLocale* locale, int day, uintptr_t
}
void QCalendar_StandaloneWeekDayName3(QCalendar* self, QLocale* locale, int day, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->standaloneWeekDayName(*locale, static_cast<int>(day), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QCalendar*>(self)->standaloneWeekDayName(*locale, static_cast<int>(day), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

42
qt/gen_qcborvalue.cpp
View File

@ -385,32 +385,32 @@ void QCborValue_ToDiagnosticNotation(QCborValue* self, char** _out, int* _out_St
}
long long QCborValue_ToInteger1(QCborValue* self, long long defaultValue) {
return self->toInteger(static_cast<qint64>(defaultValue));
return const_cast<const QCborValue*>(self)->toInteger(static_cast<qint64>(defaultValue));
}
bool QCborValue_ToBool1(QCborValue* self, bool defaultValue) {
return self->toBool(defaultValue);
return const_cast<const QCborValue*>(self)->toBool(defaultValue);
}
double QCborValue_ToDouble1(QCborValue* self, double defaultValue) {
return self->toDouble(static_cast<double>(defaultValue));
return const_cast<const QCborValue*>(self)->toDouble(static_cast<double>(defaultValue));
}
QCborValue* QCborValue_TaggedValue1(QCborValue* self, QCborValue* defaultValue) {
QCborValue ret = self->taggedValue(*defaultValue);
QCborValue ret = const_cast<const QCborValue*>(self)->taggedValue(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QCborValue*>(new QCborValue(ret));
}
QByteArray* QCborValue_ToByteArray1(QCborValue* self, QByteArray* defaultValue) {
QByteArray ret = self->toByteArray(*defaultValue);
QByteArray ret = const_cast<const QCborValue*>(self)->toByteArray(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
void QCborValue_ToString1(QCborValue* self, const char* defaultValue, size_t defaultValue_Strlen, char** _out, int* _out_Strlen) {
QString defaultValue_QString = QString::fromUtf8(defaultValue, defaultValue_Strlen);
QString ret = self->toString(defaultValue_QString);
QString ret = const_cast<const QCborValue*>(self)->toString(defaultValue_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -419,25 +419,25 @@ void QCborValue_ToString1(QCborValue* self, const char* defaultValue, size_t def
}
QDateTime* QCborValue_ToDateTime1(QCborValue* self, QDateTime* defaultValue) {
QDateTime ret = self->toDateTime(*defaultValue);
QDateTime ret = const_cast<const QCborValue*>(self)->toDateTime(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
QUrl* QCborValue_ToUrl1(QCborValue* self, QUrl* defaultValue) {
QUrl ret = self->toUrl(*defaultValue);
QUrl ret = const_cast<const QCborValue*>(self)->toUrl(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QUrl*>(new QUrl(ret));
}
QRegularExpression* QCborValue_ToRegularExpression1(QCborValue* self, QRegularExpression* defaultValue) {
QRegularExpression ret = self->toRegularExpression(*defaultValue);
QRegularExpression ret = const_cast<const QCborValue*>(self)->toRegularExpression(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpression*>(new QRegularExpression(ret));
}
QUuid* QCborValue_ToUuid1(QCborValue* self, QUuid* defaultValue) {
QUuid ret = self->toUuid(*defaultValue);
QUuid ret = const_cast<const QCborValue*>(self)->toUuid(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QUuid*>(new QUuid(ret));
}
@ -471,7 +471,7 @@ void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt) {
}
void QCborValue_ToDiagnosticNotation1(QCborValue* self, int opts, char** _out, int* _out_Strlen) {
QString ret = self->toDiagnosticNotation(static_cast<QCborValue::DiagnosticNotationOptions>(opts));
QString ret = const_cast<const QCborValue*>(self)->toDiagnosticNotation(static_cast<QCborValue::DiagnosticNotationOptions>(opts));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -731,32 +731,32 @@ void QCborValueRef_ToDiagnosticNotation(QCborValueRef* self, char** _out, int* _
}
QCborValue* QCborValueRef_TaggedValue1(QCborValueRef* self, QCborValue* defaultValue) {
QCborValue ret = self->taggedValue(*defaultValue);
QCborValue ret = const_cast<const QCborValueRef*>(self)->taggedValue(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QCborValue*>(new QCborValue(ret));
}
long long QCborValueRef_ToInteger1(QCborValueRef* self, long long defaultValue) {
return self->toInteger(static_cast<qint64>(defaultValue));
return const_cast<const QCborValueRef*>(self)->toInteger(static_cast<qint64>(defaultValue));
}
bool QCborValueRef_ToBool1(QCborValueRef* self, bool defaultValue) {
return self->toBool(defaultValue);
return const_cast<const QCborValueRef*>(self)->toBool(defaultValue);
}
double QCborValueRef_ToDouble1(QCborValueRef* self, double defaultValue) {
return self->toDouble(static_cast<double>(defaultValue));
return const_cast<const QCborValueRef*>(self)->toDouble(static_cast<double>(defaultValue));
}
QByteArray* QCborValueRef_ToByteArray1(QCborValueRef* self, QByteArray* defaultValue) {
QByteArray ret = self->toByteArray(*defaultValue);
QByteArray ret = const_cast<const QCborValueRef*>(self)->toByteArray(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
void QCborValueRef_ToString1(QCborValueRef* self, const char* defaultValue, size_t defaultValue_Strlen, char** _out, int* _out_Strlen) {
QString defaultValue_QString = QString::fromUtf8(defaultValue, defaultValue_Strlen);
QString ret = self->toString(defaultValue_QString);
QString ret = const_cast<const QCborValueRef*>(self)->toString(defaultValue_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -765,25 +765,25 @@ void QCborValueRef_ToString1(QCborValueRef* self, const char* defaultValue, size
}
QDateTime* QCborValueRef_ToDateTime1(QCborValueRef* self, QDateTime* defaultValue) {
QDateTime ret = self->toDateTime(*defaultValue);
QDateTime ret = const_cast<const QCborValueRef*>(self)->toDateTime(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
QUrl* QCborValueRef_ToUrl1(QCborValueRef* self, QUrl* defaultValue) {
QUrl ret = self->toUrl(*defaultValue);
QUrl ret = const_cast<const QCborValueRef*>(self)->toUrl(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QUrl*>(new QUrl(ret));
}
QRegularExpression* QCborValueRef_ToRegularExpression1(QCborValueRef* self, QRegularExpression* defaultValue) {
QRegularExpression ret = self->toRegularExpression(*defaultValue);
QRegularExpression ret = const_cast<const QCborValueRef*>(self)->toRegularExpression(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpression*>(new QRegularExpression(ret));
}
QUuid* QCborValueRef_ToUuid1(QCborValueRef* self, QUuid* defaultValue) {
QUuid ret = self->toUuid(*defaultValue);
QUuid ret = const_cast<const QCborValueRef*>(self)->toUuid(*defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QUuid*>(new QUuid(ret));
}

10
qt/gen_qclipboard.cpp
View File

@ -193,7 +193,7 @@ void QClipboard_Clear1(QClipboard* self, uintptr_t mode) {
}
void QClipboard_Text1(QClipboard* self, uintptr_t mode, char** _out, int* _out_Strlen) {
QString ret = self->text(static_cast<QClipboard::Mode>(mode));
QString ret = const_cast<const QClipboard*>(self)->text(static_cast<QClipboard::Mode>(mode));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -203,7 +203,7 @@ void QClipboard_Text1(QClipboard* self, uintptr_t mode, char** _out, int* _out_S
void QClipboard_Text2(QClipboard* self, const char* subtype, size_t subtype_Strlen, uintptr_t mode, char** _out, int* _out_Strlen) {
QString subtype_QString = QString::fromUtf8(subtype, subtype_Strlen);
QString ret = self->text(subtype_QString, static_cast<QClipboard::Mode>(mode));
QString ret = const_cast<const QClipboard*>(self)->text(subtype_QString, static_cast<QClipboard::Mode>(mode));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -217,7 +217,7 @@ void QClipboard_SetText2(QClipboard* self, const char* param1, size_t param1_Str
}
QMimeData* QClipboard_MimeData1(QClipboard* self, uintptr_t mode) {
return (QMimeData*) self->mimeData(static_cast<QClipboard::Mode>(mode));
return (QMimeData*) const_cast<const QClipboard*>(self)->mimeData(static_cast<QClipboard::Mode>(mode));
}
void QClipboard_SetMimeData2(QClipboard* self, QMimeData* data, uintptr_t mode) {
@ -225,13 +225,13 @@ void QClipboard_SetMimeData2(QClipboard* self, QMimeData* data, uintptr_t mode)
}
QImage* QClipboard_Image1(QClipboard* self, uintptr_t mode) {
QImage ret = self->image(static_cast<QClipboard::Mode>(mode));
QImage ret = const_cast<const QClipboard*>(self)->image(static_cast<QClipboard::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QPixmap* QClipboard_Pixmap1(QClipboard* self, uintptr_t mode) {
QPixmap ret = self->pixmap(static_cast<QClipboard::Mode>(mode));
QPixmap ret = const_cast<const QClipboard*>(self)->pixmap(static_cast<QClipboard::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}

24
qt/gen_qcolor.cpp
View File

@ -522,7 +522,7 @@ bool QColor_IsValidColor(const char* name, size_t name_Strlen) {
}
void QColor_GetRgb4(QColor* self, int* r, int* g, int* b, int* a) {
self->getRgb(static_cast<int*>(r), static_cast<int*>(g), static_cast<int*>(b), static_cast<int*>(a));
const_cast<const QColor*>(self)->getRgb(static_cast<int*>(r), static_cast<int*>(g), static_cast<int*>(b), static_cast<int*>(a));
}
void QColor_SetRgb4(QColor* self, int r, int g, int b, int a) {
@ -530,7 +530,7 @@ void QColor_SetRgb4(QColor* self, int r, int g, int b, int a) {
}
void QColor_GetRgbF4(QColor* self, double* r, double* g, double* b, double* a) {
self->getRgbF(static_cast<qreal*>(r), static_cast<qreal*>(g), static_cast<qreal*>(b), static_cast<qreal*>(a));
const_cast<const QColor*>(self)->getRgbF(static_cast<qreal*>(r), static_cast<qreal*>(g), static_cast<qreal*>(b), static_cast<qreal*>(a));
}
void QColor_SetRgbF4(QColor* self, double r, double g, double b, double a) {
@ -538,7 +538,7 @@ void QColor_SetRgbF4(QColor* self, double r, double g, double b, double a) {
}
void QColor_GetHsv4(QColor* self, int* h, int* s, int* v, int* a) {
self->getHsv(static_cast<int*>(h), static_cast<int*>(s), static_cast<int*>(v), static_cast<int*>(a));
const_cast<const QColor*>(self)->getHsv(static_cast<int*>(h), static_cast<int*>(s), static_cast<int*>(v), static_cast<int*>(a));
}
void QColor_SetHsv4(QColor* self, int h, int s, int v, int a) {
@ -546,7 +546,7 @@ void QColor_SetHsv4(QColor* self, int h, int s, int v, int a) {
}
void QColor_GetHsvF4(QColor* self, double* h, double* s, double* v, double* a) {
self->getHsvF(static_cast<qreal*>(h), static_cast<qreal*>(s), static_cast<qreal*>(v), static_cast<qreal*>(a));
const_cast<const QColor*>(self)->getHsvF(static_cast<qreal*>(h), static_cast<qreal*>(s), static_cast<qreal*>(v), static_cast<qreal*>(a));
}
void QColor_SetHsvF4(QColor* self, double h, double s, double v, double a) {
@ -558,7 +558,7 @@ void QColor_GetCmyk5(QColor* self, int* c, int* m, int* y, int* k, int* a) {
}
void QColor_GetCmyk52(QColor* self, int* c, int* m, int* y, int* k, int* a) {
self->getCmyk(static_cast<int*>(c), static_cast<int*>(m), static_cast<int*>(y), static_cast<int*>(k), static_cast<int*>(a));
const_cast<const QColor*>(self)->getCmyk(static_cast<int*>(c), static_cast<int*>(m), static_cast<int*>(y), static_cast<int*>(k), static_cast<int*>(a));
}
void QColor_SetCmyk5(QColor* self, int c, int m, int y, int k, int a) {
@ -570,7 +570,7 @@ void QColor_GetCmykF5(QColor* self, double* c, double* m, double* y, double* k,
}
void QColor_GetCmykF52(QColor* self, double* c, double* m, double* y, double* k, double* a) {
self->getCmykF(static_cast<qreal*>(c), static_cast<qreal*>(m), static_cast<qreal*>(y), static_cast<qreal*>(k), static_cast<qreal*>(a));
const_cast<const QColor*>(self)->getCmykF(static_cast<qreal*>(c), static_cast<qreal*>(m), static_cast<qreal*>(y), static_cast<qreal*>(k), static_cast<qreal*>(a));
}
void QColor_SetCmykF5(QColor* self, double c, double m, double y, double k, double a) {
@ -578,7 +578,7 @@ void QColor_SetCmykF5(QColor* self, double c, double m, double y, double k, doub
}
void QColor_GetHsl4(QColor* self, int* h, int* s, int* l, int* a) {
self->getHsl(static_cast<int*>(h), static_cast<int*>(s), static_cast<int*>(l), static_cast<int*>(a));
const_cast<const QColor*>(self)->getHsl(static_cast<int*>(h), static_cast<int*>(s), static_cast<int*>(l), static_cast<int*>(a));
}
void QColor_SetHsl4(QColor* self, int h, int s, int l, int a) {
@ -586,7 +586,7 @@ void QColor_SetHsl4(QColor* self, int h, int s, int l, int a) {
}
void QColor_GetHslF4(QColor* self, double* h, double* s, double* l, double* a) {
self->getHslF(static_cast<qreal*>(h), static_cast<qreal*>(s), static_cast<qreal*>(l), static_cast<qreal*>(a));
const_cast<const QColor*>(self)->getHslF(static_cast<qreal*>(h), static_cast<qreal*>(s), static_cast<qreal*>(l), static_cast<qreal*>(a));
}
void QColor_SetHslF4(QColor* self, double h, double s, double l, double a) {
@ -648,25 +648,25 @@ QColor* QColor_FromHslF4(double h, double s, double l, double a) {
}
QColor* QColor_Light1(QColor* self, int f) {
QColor ret = self->light(static_cast<int>(f));
QColor ret = const_cast<const QColor*>(self)->light(static_cast<int>(f));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QColor*>(new QColor(ret));
}
QColor* QColor_Dark1(QColor* self, int f) {
QColor ret = self->dark(static_cast<int>(f));
QColor ret = const_cast<const QColor*>(self)->dark(static_cast<int>(f));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QColor*>(new QColor(ret));
}
QColor* QColor_Lighter1(QColor* self, int f) {
QColor ret = self->lighter(static_cast<int>(f));
QColor ret = const_cast<const QColor*>(self)->lighter(static_cast<int>(f));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QColor*>(new QColor(ret));
}
QColor* QColor_Darker1(QColor* self, int f) {
QColor ret = self->darker(static_cast<int>(f));
QColor ret = const_cast<const QColor*>(self)->darker(static_cast<int>(f));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QColor*>(new QColor(ret));
}

2
qt/gen_qcolorspace.cpp
View File

@ -109,7 +109,7 @@ void QColorSpace_SetTransferFunction2(QColorSpace* self, uintptr_t transferFunct
}
QColorSpace* QColorSpace_WithTransferFunction2(QColorSpace* self, uintptr_t transferFunction, float gamma) {
QColorSpace ret = self->withTransferFunction(static_cast<QColorSpace::TransferFunction>(transferFunction), static_cast<float>(gamma));
QColorSpace ret = const_cast<const QColorSpace*>(self)->withTransferFunction(static_cast<QColorSpace::TransferFunction>(transferFunction), static_cast<float>(gamma));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QColorSpace*>(new QColorSpace(ret));
}

10
qt/gen_qcombobox.cpp
View File

@ -542,25 +542,25 @@ void QComboBox_TrUtf83(const char* s, const char* c, int n, char** _out, int* _o
int QComboBox_FindText2(QComboBox* self, const char* text, size_t text_Strlen, int flags) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
return self->findText(text_QString, static_cast<Qt::MatchFlags>(flags));
return const_cast<const QComboBox*>(self)->findText(text_QString, static_cast<Qt::MatchFlags>(flags));
}
int QComboBox_FindData2(QComboBox* self, QVariant* data, int role) {
return self->findData(*data, static_cast<int>(role));
return const_cast<const QComboBox*>(self)->findData(*data, static_cast<int>(role));
}
int QComboBox_FindData3(QComboBox* self, QVariant* data, int role, int flags) {
return self->findData(*data, static_cast<int>(role), static_cast<Qt::MatchFlags>(flags));
return const_cast<const QComboBox*>(self)->findData(*data, static_cast<int>(role), static_cast<Qt::MatchFlags>(flags));
}
QVariant* QComboBox_CurrentData1(QComboBox* self, int role) {
QVariant ret = self->currentData(static_cast<int>(role));
QVariant ret = const_cast<const QComboBox*>(self)->currentData(static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
QVariant* QComboBox_ItemData2(QComboBox* self, int index, int role) {
QVariant ret = self->itemData(static_cast<int>(index), static_cast<int>(role));
QVariant ret = const_cast<const QComboBox*>(self)->itemData(static_cast<int>(index), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}

36
qt/gen_qcommonstyle.cpp
View File

@ -171,90 +171,90 @@ void QCommonStyle_TrUtf83(const char* s, const char* c, int n, char** _out, int*
}
void QCommonStyle_DrawPrimitive4(QCommonStyle* self, uintptr_t pe, QStyleOption* opt, QPainter* p, QWidget* w) {
self->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), opt, p, w);
const_cast<const QCommonStyle*>(self)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), opt, p, w);
}
void QCommonStyle_DrawControl4(QCommonStyle* self, uintptr_t element, QStyleOption* opt, QPainter* p, QWidget* w) {
self->drawControl(static_cast<QStyle::ControlElement>(element), opt, p, w);
const_cast<const QCommonStyle*>(self)->drawControl(static_cast<QStyle::ControlElement>(element), opt, p, w);
}
QRect* QCommonStyle_SubElementRect3(QCommonStyle* self, uintptr_t r, QStyleOption* opt, QWidget* widget) {
QRect ret = self->subElementRect(static_cast<QStyle::SubElement>(r), opt, widget);
QRect ret = const_cast<const QCommonStyle*>(self)->subElementRect(static_cast<QStyle::SubElement>(r), opt, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
void QCommonStyle_DrawComplexControl4(QCommonStyle* self, uintptr_t cc, QStyleOptionComplex* opt, QPainter* p, QWidget* w) {
self->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, p, w);
const_cast<const QCommonStyle*>(self)->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, p, w);
}
uintptr_t QCommonStyle_HitTestComplexControl4(QCommonStyle* self, uintptr_t cc, QStyleOptionComplex* opt, QPoint* pt, QWidget* w) {
QStyle::SubControl ret = self->hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, *pt, w);
QStyle::SubControl ret = const_cast<const QCommonStyle*>(self)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, *pt, w);
return static_cast<uintptr_t>(ret);
}
QRect* QCommonStyle_SubControlRect4(QCommonStyle* self, uintptr_t cc, QStyleOptionComplex* opt, uintptr_t sc, QWidget* w) {
QRect ret = self->subControlRect(static_cast<QStyle::ComplexControl>(cc), opt, static_cast<QStyle::SubControl>(sc), w);
QRect ret = const_cast<const QCommonStyle*>(self)->subControlRect(static_cast<QStyle::ComplexControl>(cc), opt, static_cast<QStyle::SubControl>(sc), w);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QSize* QCommonStyle_SizeFromContents4(QCommonStyle* self, uintptr_t ct, QStyleOption* opt, QSize* contentsSize, QWidget* widget) {
QSize ret = self->sizeFromContents(static_cast<QStyle::ContentsType>(ct), opt, *contentsSize, widget);
QSize ret = const_cast<const QCommonStyle*>(self)->sizeFromContents(static_cast<QStyle::ContentsType>(ct), opt, *contentsSize, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
int QCommonStyle_PixelMetric2(QCommonStyle* self, uintptr_t m, QStyleOption* opt) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(m), opt);
return const_cast<const QCommonStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(m), opt);
}
int QCommonStyle_PixelMetric3(QCommonStyle* self, uintptr_t m, QStyleOption* opt, QWidget* widget) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(m), opt, widget);
return const_cast<const QCommonStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(m), opt, widget);
}
int QCommonStyle_StyleHint2(QCommonStyle* self, uintptr_t sh, QStyleOption* opt) {
return self->styleHint(static_cast<QStyle::StyleHint>(sh), opt);
return const_cast<const QCommonStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(sh), opt);
}
int QCommonStyle_StyleHint3(QCommonStyle* self, uintptr_t sh, QStyleOption* opt, QWidget* w) {
return self->styleHint(static_cast<QStyle::StyleHint>(sh), opt, w);
return const_cast<const QCommonStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(sh), opt, w);
}
int QCommonStyle_StyleHint4(QCommonStyle* self, uintptr_t sh, QStyleOption* opt, QWidget* w, QStyleHintReturn* shret) {
return self->styleHint(static_cast<QStyle::StyleHint>(sh), opt, w, shret);
return const_cast<const QCommonStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(sh), opt, w, shret);
}
QIcon* QCommonStyle_StandardIcon2(QCommonStyle* self, uintptr_t standardIcon, QStyleOption* opt) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), opt);
QIcon ret = const_cast<const QCommonStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), opt);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
QIcon* QCommonStyle_StandardIcon3(QCommonStyle* self, uintptr_t standardIcon, QStyleOption* opt, QWidget* widget) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), opt, widget);
QIcon ret = const_cast<const QCommonStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), opt, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
QPixmap* QCommonStyle_StandardPixmap2(QCommonStyle* self, uintptr_t sp, QStyleOption* opt) {
QPixmap ret = self->standardPixmap(static_cast<QStyle::StandardPixmap>(sp), opt);
QPixmap ret = const_cast<const QCommonStyle*>(self)->standardPixmap(static_cast<QStyle::StandardPixmap>(sp), opt);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QCommonStyle_StandardPixmap3(QCommonStyle* self, uintptr_t sp, QStyleOption* opt, QWidget* widget) {
QPixmap ret = self->standardPixmap(static_cast<QStyle::StandardPixmap>(sp), opt, widget);
QPixmap ret = const_cast<const QCommonStyle*>(self)->standardPixmap(static_cast<QStyle::StandardPixmap>(sp), opt, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
int QCommonStyle_LayoutSpacing4(QCommonStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
return const_cast<const QCommonStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
}
int QCommonStyle_LayoutSpacing5(QCommonStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option, QWidget* widget) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
return const_cast<const QCommonStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
}
void QCommonStyle_Delete(QCommonStyle* self) {

10
qt/gen_qconcatenatetablesproxymodel.cpp
View File

@ -197,7 +197,7 @@ void QConcatenateTablesProxyModel_TrUtf83(const char* s, const char* c, int n, c
}
QVariant* QConcatenateTablesProxyModel_Data2(QConcatenateTablesProxyModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QConcatenateTablesProxyModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -207,23 +207,23 @@ bool QConcatenateTablesProxyModel_SetData3(QConcatenateTablesProxyModel* self, Q
}
QModelIndex* QConcatenateTablesProxyModel_Index3(QConcatenateTablesProxyModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QConcatenateTablesProxyModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QConcatenateTablesProxyModel_RowCount1(QConcatenateTablesProxyModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QConcatenateTablesProxyModel*>(self)->rowCount(*parent);
}
QVariant* QConcatenateTablesProxyModel_HeaderData3(QConcatenateTablesProxyModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QConcatenateTablesProxyModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
int QConcatenateTablesProxyModel_ColumnCount1(QConcatenateTablesProxyModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QConcatenateTablesProxyModel*>(self)->columnCount(*parent);
}
void QConcatenateTablesProxyModel_Delete(QConcatenateTablesProxyModel* self) {

16
qt/gen_qdatetime.cpp
View File

@ -318,29 +318,29 @@ long long QDate_ToJulianDay(QDate* self) {
}
int QDate_WeekNumber1(QDate* self, int* yearNum) {
return self->weekNumber(static_cast<int*>(yearNum));
return const_cast<const QDate*>(self)->weekNumber(static_cast<int*>(yearNum));
}
QDateTime* QDate_StartOfDay1(QDate* self, uintptr_t spec) {
QDateTime ret = self->startOfDay(static_cast<Qt::TimeSpec>(spec));
QDateTime ret = const_cast<const QDate*>(self)->startOfDay(static_cast<Qt::TimeSpec>(spec));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
QDateTime* QDate_StartOfDay2(QDate* self, uintptr_t spec, int offsetSeconds) {
QDateTime ret = self->startOfDay(static_cast<Qt::TimeSpec>(spec), static_cast<int>(offsetSeconds));
QDateTime ret = const_cast<const QDate*>(self)->startOfDay(static_cast<Qt::TimeSpec>(spec), static_cast<int>(offsetSeconds));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
QDateTime* QDate_EndOfDay1(QDate* self, uintptr_t spec) {
QDateTime ret = self->endOfDay(static_cast<Qt::TimeSpec>(spec));
QDateTime ret = const_cast<const QDate*>(self)->endOfDay(static_cast<Qt::TimeSpec>(spec));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
QDateTime* QDate_EndOfDay2(QDate* self, uintptr_t spec, int offsetSeconds) {
QDateTime ret = self->endOfDay(static_cast<Qt::TimeSpec>(spec), static_cast<int>(offsetSeconds));
QDateTime ret = const_cast<const QDate*>(self)->endOfDay(static_cast<Qt::TimeSpec>(spec), static_cast<int>(offsetSeconds));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
@ -382,7 +382,7 @@ void QDate_LongDayName2(int weekday, uintptr_t typeVal, char** _out, int* _out_S
}
void QDate_ToString1(QDate* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<Qt::DateFormat>(format));
QString ret = const_cast<const QDate*>(self)->toString(static_cast<Qt::DateFormat>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -560,7 +560,7 @@ int QTime_Elapsed(QTime* self) {
}
void QTime_ToString1(QTime* self, uintptr_t f, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<Qt::DateFormat>(f));
QString ret = const_cast<const QTime*>(self)->toString(static_cast<Qt::DateFormat>(f));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -936,7 +936,7 @@ long long QDateTime_CurrentSecsSinceEpoch() {
}
void QDateTime_ToString1(QDateTime* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<Qt::DateFormat>(format));
QString ret = const_cast<const QDateTime*>(self)->toString(static_cast<Qt::DateFormat>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

6
qt/gen_qdesktopwidget.cpp
View File

@ -181,7 +181,7 @@ void QDesktopWidget_TrUtf83(const char* s, const char* c, int n, char** _out, in
}
int QDesktopWidget_ScreenNumber1(QDesktopWidget* self, QWidget* widget) {
return self->screenNumber(widget);
return const_cast<const QDesktopWidget*>(self)->screenNumber(widget);
}
QWidget* QDesktopWidget_Screen1(QDesktopWidget* self, int screen) {
@ -189,13 +189,13 @@ QWidget* QDesktopWidget_Screen1(QDesktopWidget* self, int screen) {
}
QRect* QDesktopWidget_ScreenGeometry1(QDesktopWidget* self, int screen) {
QRect ret = self->screenGeometry(static_cast<int>(screen));
QRect ret = const_cast<const QDesktopWidget*>(self)->screenGeometry(static_cast<int>(screen));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QRect* QDesktopWidget_AvailableGeometry1(QDesktopWidget* self, int screen) {
QRect ret = self->availableGeometry(static_cast<int>(screen));
QRect ret = const_cast<const QDesktopWidget*>(self)->availableGeometry(static_cast<int>(screen));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}

18
qt/gen_qdir.cpp
View File

@ -542,11 +542,11 @@ void QDir_Refresh(QDir* self) {
}
bool QDir_IsEmpty1(QDir* self, int filters) {
return self->isEmpty(static_cast<QDir::Filters>(filters));
return const_cast<const QDir*>(self)->isEmpty(static_cast<QDir::Filters>(filters));
}
void QDir_EntryList1(QDir* self, int filters, char*** _out, int** _out_Lengths, size_t* _out_len) {
QStringList ret = self->entryList(static_cast<QDir::Filters>(filters));
QStringList ret = const_cast<const QDir*>(self)->entryList(static_cast<QDir::Filters>(filters));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));
@ -563,7 +563,7 @@ void QDir_EntryList1(QDir* self, int filters, char*** _out, int** _out_Lengths,
}
void QDir_EntryList2(QDir* self, int filters, int sort, char*** _out, int** _out_Lengths, size_t* _out_len) {
QStringList ret = self->entryList(static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
QStringList ret = const_cast<const QDir*>(self)->entryList(static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));
@ -585,7 +585,7 @@ void QDir_EntryList22(QDir* self, char** nameFilters, uint64_t* nameFilters_Leng
for(size_t i = 0; i < nameFilters_len; ++i) {
nameFilters_QList.push_back(QString::fromUtf8(nameFilters[i], nameFilters_Lengths[i]));
}
QStringList ret = self->entryList(nameFilters_QList, static_cast<QDir::Filters>(filters));
QStringList ret = const_cast<const QDir*>(self)->entryList(nameFilters_QList, static_cast<QDir::Filters>(filters));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));
@ -607,7 +607,7 @@ void QDir_EntryList3(QDir* self, char** nameFilters, uint64_t* nameFilters_Lengt
for(size_t i = 0; i < nameFilters_len; ++i) {
nameFilters_QList.push_back(QString::fromUtf8(nameFilters[i], nameFilters_Lengths[i]));
}
QStringList ret = self->entryList(nameFilters_QList, static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
QStringList ret = const_cast<const QDir*>(self)->entryList(nameFilters_QList, static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));
@ -624,7 +624,7 @@ void QDir_EntryList3(QDir* self, char** nameFilters, uint64_t* nameFilters_Lengt
}
void QDir_EntryInfoList1(QDir* self, int filters, QFileInfo*** _out, size_t* _out_len) {
QFileInfoList ret = self->entryInfoList(static_cast<QDir::Filters>(filters));
QFileInfoList ret = const_cast<const QDir*>(self)->entryInfoList(static_cast<QDir::Filters>(filters));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QFileInfo** __out = static_cast<QFileInfo**>(malloc(sizeof(QFileInfo**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -635,7 +635,7 @@ void QDir_EntryInfoList1(QDir* self, int filters, QFileInfo*** _out, size_t* _ou
}
void QDir_EntryInfoList2(QDir* self, int filters, int sort, QFileInfo*** _out, size_t* _out_len) {
QFileInfoList ret = self->entryInfoList(static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
QFileInfoList ret = const_cast<const QDir*>(self)->entryInfoList(static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QFileInfo** __out = static_cast<QFileInfo**>(malloc(sizeof(QFileInfo**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -651,7 +651,7 @@ void QDir_EntryInfoList22(QDir* self, char** nameFilters, uint64_t* nameFilters_
for(size_t i = 0; i < nameFilters_len; ++i) {
nameFilters_QList.push_back(QString::fromUtf8(nameFilters[i], nameFilters_Lengths[i]));
}
QFileInfoList ret = self->entryInfoList(nameFilters_QList, static_cast<QDir::Filters>(filters));
QFileInfoList ret = const_cast<const QDir*>(self)->entryInfoList(nameFilters_QList, static_cast<QDir::Filters>(filters));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QFileInfo** __out = static_cast<QFileInfo**>(malloc(sizeof(QFileInfo**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -667,7 +667,7 @@ void QDir_EntryInfoList3(QDir* self, char** nameFilters, uint64_t* nameFilters_L
for(size_t i = 0; i < nameFilters_len; ++i) {
nameFilters_QList.push_back(QString::fromUtf8(nameFilters[i], nameFilters_Lengths[i]));
}
QFileInfoList ret = self->entryInfoList(nameFilters_QList, static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
QFileInfoList ret = const_cast<const QDir*>(self)->entryInfoList(nameFilters_QList, static_cast<QDir::Filters>(filters), static_cast<QDir::SortFlags>(sort));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QFileInfo** __out = static_cast<QFileInfo**>(malloc(sizeof(QFileInfo**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

14
qt/gen_qdirmodel.cpp
View File

@ -324,21 +324,21 @@ void QDirModel_TrUtf83(const char* s, const char* c, int n, char** _out, int* _o
}
QModelIndex* QDirModel_Index3(QDirModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QDirModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QDirModel_RowCount1(QDirModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QDirModel*>(self)->rowCount(*parent);
}
int QDirModel_ColumnCount1(QDirModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QDirModel*>(self)->columnCount(*parent);
}
QVariant* QDirModel_Data2(QDirModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QDirModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -348,13 +348,13 @@ bool QDirModel_SetData3(QDirModel* self, QModelIndex* index, QVariant* value, in
}
QVariant* QDirModel_HeaderData3(QDirModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QDirModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
bool QDirModel_HasChildren1(QDirModel* self, QModelIndex* index) {
return self->hasChildren(*index);
return const_cast<const QDirModel*>(self)->hasChildren(*index);
}
void QDirModel_Sort2(QDirModel* self, int column, uintptr_t order) {
@ -363,7 +363,7 @@ void QDirModel_Sort2(QDirModel* self, int column, uintptr_t order) {
QModelIndex* QDirModel_Index2(QDirModel* self, const char* path, size_t path_Strlen, int column) {
QString path_QString = QString::fromUtf8(path, path_Strlen);
QModelIndex ret = self->index(path_QString, static_cast<int>(column));
QModelIndex ret = const_cast<const QDirModel*>(self)->index(path_QString, static_cast<int>(column));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}

16
qt/gen_qfilesystemmodel.cpp
View File

@ -413,38 +413,38 @@ void QFileSystemModel_TrUtf83(const char* s, const char* c, int n, char** _out,
}
QModelIndex* QFileSystemModel_Index3(QFileSystemModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QFileSystemModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
QModelIndex* QFileSystemModel_Index2(QFileSystemModel* self, const char* path, size_t path_Strlen, int column) {
QString path_QString = QString::fromUtf8(path, path_Strlen);
QModelIndex ret = self->index(path_QString, static_cast<int>(column));
QModelIndex ret = const_cast<const QFileSystemModel*>(self)->index(path_QString, static_cast<int>(column));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
bool QFileSystemModel_HasChildren1(QFileSystemModel* self, QModelIndex* parent) {
return self->hasChildren(*parent);
return const_cast<const QFileSystemModel*>(self)->hasChildren(*parent);
}
int QFileSystemModel_RowCount1(QFileSystemModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QFileSystemModel*>(self)->rowCount(*parent);
}
int QFileSystemModel_ColumnCount1(QFileSystemModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QFileSystemModel*>(self)->columnCount(*parent);
}
QVariant* QFileSystemModel_MyComputer1(QFileSystemModel* self, int role) {
QVariant ret = self->myComputer(static_cast<int>(role));
QVariant ret = const_cast<const QFileSystemModel*>(self)->myComputer(static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
QVariant* QFileSystemModel_Data2(QFileSystemModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QFileSystemModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -454,7 +454,7 @@ bool QFileSystemModel_SetData3(QFileSystemModel* self, QModelIndex* index, QVari
}
QVariant* QFileSystemModel_HeaderData3(QFileSystemModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QFileSystemModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}

10
qt/gen_qfontdatabase.cpp
View File

@ -249,7 +249,7 @@ QFont* QFontDatabase_SystemFont(uintptr_t typeVal) {
}
void QFontDatabase_Families1(QFontDatabase* self, uintptr_t writingSystem, char*** _out, int** _out_Lengths, size_t* _out_len) {
QStringList ret = self->families(static_cast<QFontDatabase::WritingSystem>(writingSystem));
QStringList ret = const_cast<const QFontDatabase*>(self)->families(static_cast<QFontDatabase::WritingSystem>(writingSystem));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));
@ -281,25 +281,25 @@ void QFontDatabase_PointSizes2(QFontDatabase* self, const char* family, size_t f
bool QFontDatabase_IsBitmapScalable2(QFontDatabase* self, const char* family, size_t family_Strlen, const char* style, size_t style_Strlen) {
QString family_QString = QString::fromUtf8(family, family_Strlen);
QString style_QString = QString::fromUtf8(style, style_Strlen);
return self->isBitmapScalable(family_QString, style_QString);
return const_cast<const QFontDatabase*>(self)->isBitmapScalable(family_QString, style_QString);
}
bool QFontDatabase_IsSmoothlyScalable2(QFontDatabase* self, const char* family, size_t family_Strlen, const char* style, size_t style_Strlen) {
QString family_QString = QString::fromUtf8(family, family_Strlen);
QString style_QString = QString::fromUtf8(style, style_Strlen);
return self->isSmoothlyScalable(family_QString, style_QString);
return const_cast<const QFontDatabase*>(self)->isSmoothlyScalable(family_QString, style_QString);
}
bool QFontDatabase_IsScalable2(QFontDatabase* self, const char* family, size_t family_Strlen, const char* style, size_t style_Strlen) {
QString family_QString = QString::fromUtf8(family, family_Strlen);
QString style_QString = QString::fromUtf8(style, style_Strlen);
return self->isScalable(family_QString, style_QString);
return const_cast<const QFontDatabase*>(self)->isScalable(family_QString, style_QString);
}
bool QFontDatabase_IsFixedPitch2(QFontDatabase* self, const char* family, size_t family_Strlen, const char* style, size_t style_Strlen) {
QString family_QString = QString::fromUtf8(family, family_Strlen);
QString style_QString = QString::fromUtf8(style, style_Strlen);
return self->isFixedPitch(family_QString, style_QString);
return const_cast<const QFontDatabase*>(self)->isFixedPitch(family_QString, style_QString);
}
void QFontDatabase_Delete(QFontDatabase* self) {

30
qt/gen_qfontmetrics.cpp
View File

@ -207,59 +207,59 @@ bool QFontMetrics_OperatorNotEqual(QFontMetrics* self, QFontMetrics* other) {
int QFontMetrics_Width22(QFontMetrics* self, const char* param1, size_t param1_Strlen, int lenVal) {
QString param1_QString = QString::fromUtf8(param1, param1_Strlen);
return self->width(param1_QString, static_cast<int>(lenVal));
return const_cast<const QFontMetrics*>(self)->width(param1_QString, static_cast<int>(lenVal));
}
int QFontMetrics_HorizontalAdvance2(QFontMetrics* self, const char* param1, size_t param1_Strlen, int lenVal) {
QString param1_QString = QString::fromUtf8(param1, param1_Strlen);
return self->horizontalAdvance(param1_QString, static_cast<int>(lenVal));
return const_cast<const QFontMetrics*>(self)->horizontalAdvance(param1_QString, static_cast<int>(lenVal));
}
QRect* QFontMetrics_BoundingRect4(QFontMetrics* self, QRect* r, int flags, const char* text, size_t text_Strlen, int tabstops) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QRect ret = self->boundingRect(*r, static_cast<int>(flags), text_QString, static_cast<int>(tabstops));
QRect ret = const_cast<const QFontMetrics*>(self)->boundingRect(*r, static_cast<int>(flags), text_QString, static_cast<int>(tabstops));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QRect* QFontMetrics_BoundingRect5(QFontMetrics* self, QRect* r, int flags, const char* text, size_t text_Strlen, int tabstops, int* tabarray) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QRect ret = self->boundingRect(*r, static_cast<int>(flags), text_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
QRect ret = const_cast<const QFontMetrics*>(self)->boundingRect(*r, static_cast<int>(flags), text_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QRect* QFontMetrics_BoundingRect7(QFontMetrics* self, int x, int y, int w, int h, int flags, const char* text, size_t text_Strlen, int tabstops) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QRect ret = self->boundingRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<int>(flags), text_QString, static_cast<int>(tabstops));
QRect ret = const_cast<const QFontMetrics*>(self)->boundingRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<int>(flags), text_QString, static_cast<int>(tabstops));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QRect* QFontMetrics_BoundingRect8(QFontMetrics* self, int x, int y, int w, int h, int flags, const char* text, size_t text_Strlen, int tabstops, int* tabarray) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QRect ret = self->boundingRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<int>(flags), text_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
QRect ret = const_cast<const QFontMetrics*>(self)->boundingRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<int>(flags), text_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
QSize* QFontMetrics_Size3(QFontMetrics* self, int flags, const char* str, size_t str_Strlen, int tabstops) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
QSize ret = self->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops));
QSize ret = const_cast<const QFontMetrics*>(self)->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
QSize* QFontMetrics_Size4(QFontMetrics* self, int flags, const char* str, size_t str_Strlen, int tabstops, int* tabarray) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
QSize ret = self->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
QSize ret = const_cast<const QFontMetrics*>(self)->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
void QFontMetrics_ElidedText4(QFontMetrics* self, const char* text, size_t text_Strlen, uintptr_t mode, int width, int flags, char** _out, int* _out_Strlen) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QString ret = self->elidedText(text_QString, static_cast<Qt::TextElideMode>(mode), static_cast<int>(width), static_cast<int>(flags));
QString ret = const_cast<const QFontMetrics*>(self)->elidedText(text_QString, static_cast<Qt::TextElideMode>(mode), static_cast<int>(width), static_cast<int>(flags));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -451,40 +451,40 @@ bool QFontMetricsF_OperatorNotEqual(QFontMetricsF* self, QFontMetricsF* other) {
double QFontMetricsF_HorizontalAdvance2(QFontMetricsF* self, const char* stringVal, size_t stringVal_Strlen, int length) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
return self->horizontalAdvance(stringVal_QString, static_cast<int>(length));
return const_cast<const QFontMetricsF*>(self)->horizontalAdvance(stringVal_QString, static_cast<int>(length));
}
QRectF* QFontMetricsF_BoundingRect4(QFontMetricsF* self, QRectF* r, int flags, const char* stringVal, size_t stringVal_Strlen, int tabstops) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
QRectF ret = self->boundingRect(*r, static_cast<int>(flags), stringVal_QString, static_cast<int>(tabstops));
QRectF ret = const_cast<const QFontMetricsF*>(self)->boundingRect(*r, static_cast<int>(flags), stringVal_QString, static_cast<int>(tabstops));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRectF*>(new QRectF(ret));
}
QRectF* QFontMetricsF_BoundingRect5(QFontMetricsF* self, QRectF* r, int flags, const char* stringVal, size_t stringVal_Strlen, int tabstops, int* tabarray) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
QRectF ret = self->boundingRect(*r, static_cast<int>(flags), stringVal_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
QRectF ret = const_cast<const QFontMetricsF*>(self)->boundingRect(*r, static_cast<int>(flags), stringVal_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRectF*>(new QRectF(ret));
}
QSizeF* QFontMetricsF_Size3(QFontMetricsF* self, int flags, const char* str, size_t str_Strlen, int tabstops) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
QSizeF ret = self->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops));
QSizeF ret = const_cast<const QFontMetricsF*>(self)->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSizeF*>(new QSizeF(ret));
}
QSizeF* QFontMetricsF_Size4(QFontMetricsF* self, int flags, const char* str, size_t str_Strlen, int tabstops, int* tabarray) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
QSizeF ret = self->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
QSizeF ret = const_cast<const QFontMetricsF*>(self)->size(static_cast<int>(flags), str_QString, static_cast<int>(tabstops), static_cast<int*>(tabarray));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSizeF*>(new QSizeF(ret));
}
void QFontMetricsF_ElidedText4(QFontMetricsF* self, const char* text, size_t text_Strlen, uintptr_t mode, double width, int flags, char** _out, int* _out_Strlen) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QString ret = self->elidedText(text_QString, static_cast<Qt::TextElideMode>(mode), static_cast<qreal>(width), static_cast<int>(flags));
QString ret = const_cast<const QFontMetricsF*>(self)->elidedText(text_QString, static_cast<Qt::TextElideMode>(mode), static_cast<qreal>(width), static_cast<int>(flags));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

2
qt/gen_qgraphicsgridlayout.cpp
View File

@ -212,7 +212,7 @@ void QGraphicsGridLayout_AddItem4(QGraphicsGridLayout* self, QGraphicsLayoutItem
}
QSizeF* QGraphicsGridLayout_SizeHint2(QGraphicsGridLayout* self, uintptr_t which, QSizeF* constraint) {
QSizeF ret = self->sizeHint(static_cast<Qt::SizeHint>(which), *constraint);
QSizeF ret = const_cast<const QGraphicsGridLayout*>(self)->sizeHint(static_cast<Qt::SizeHint>(which), *constraint);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSizeF*>(new QSizeF(ret));
}

10
qt/gen_qgraphicsitem.cpp
View File

@ -877,7 +877,7 @@ void QGraphicsItem_SetMatrix2(QGraphicsItem* self, QMatrix* matrix, bool combine
}
QTransform* QGraphicsItem_ItemTransform2(QGraphicsItem* self, QGraphicsItem* other, bool* ok) {
QTransform ret = self->itemTransform(other, ok);
QTransform ret = const_cast<const QGraphicsItem*>(self)->itemTransform(other, ok);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTransform*>(new QTransform(ret));
}
@ -887,15 +887,15 @@ void QGraphicsItem_SetTransform2(QGraphicsItem* self, QTransform* matrix, bool c
}
bool QGraphicsItem_CollidesWithItem2(QGraphicsItem* self, QGraphicsItem* other, uintptr_t mode) {
return self->collidesWithItem(other, static_cast<Qt::ItemSelectionMode>(mode));
return const_cast<const QGraphicsItem*>(self)->collidesWithItem(other, static_cast<Qt::ItemSelectionMode>(mode));
}
bool QGraphicsItem_CollidesWithPath2(QGraphicsItem* self, QPainterPath* path, uintptr_t mode) {
return self->collidesWithPath(*path, static_cast<Qt::ItemSelectionMode>(mode));
return const_cast<const QGraphicsItem*>(self)->collidesWithPath(*path, static_cast<Qt::ItemSelectionMode>(mode));
}
void QGraphicsItem_CollidingItems1(QGraphicsItem* self, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->collidingItems(static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsItem*>(self)->collidingItems(static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -906,7 +906,7 @@ void QGraphicsItem_CollidingItems1(QGraphicsItem* self, uintptr_t mode, QGraphic
}
bool QGraphicsItem_IsObscured1(QGraphicsItem* self, QRectF* rect) {
return self->isObscured(*rect);
return const_cast<const QGraphicsItem*>(self)->isObscured(*rect);
}
void QGraphicsItem_Paint3(QGraphicsItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget) {

2
qt/gen_qgraphicslayoutitem.cpp
View File

@ -170,7 +170,7 @@ void QGraphicsLayoutItem_SetSizePolicy3(QGraphicsLayoutItem* self, uintptr_t hPo
}
QSizeF* QGraphicsLayoutItem_EffectiveSizeHint2(QGraphicsLayoutItem* self, uintptr_t which, QSizeF* constraint) {
QSizeF ret = self->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *constraint);
QSizeF ret = const_cast<const QGraphicsLayoutItem*>(self)->effectiveSizeHint(static_cast<Qt::SizeHint>(which), *constraint);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSizeF*>(new QSizeF(ret));
}

4
qt/gen_qgraphicslinearlayout.cpp
View File

@ -127,13 +127,13 @@ void QGraphicsLinearLayout_InsertStretch2(QGraphicsLinearLayout* self, int index
}
QSizeF* QGraphicsLinearLayout_SizeHint2(QGraphicsLinearLayout* self, uintptr_t which, QSizeF* constraint) {
QSizeF ret = self->sizeHint(static_cast<Qt::SizeHint>(which), *constraint);
QSizeF ret = const_cast<const QGraphicsLinearLayout*>(self)->sizeHint(static_cast<Qt::SizeHint>(which), *constraint);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSizeF*>(new QSizeF(ret));
}
void QGraphicsLinearLayout_Dump1(QGraphicsLinearLayout* self, int indent) {
self->dump(static_cast<int>(indent));
const_cast<const QGraphicsLinearLayout*>(self)->dump(static_cast<int>(indent));
}
void QGraphicsLinearLayout_Delete(QGraphicsLinearLayout* self) {

24
qt/gen_qgraphicsscene.cpp
View File

@ -572,7 +572,7 @@ void QGraphicsScene_Render4(QGraphicsScene* self, QPainter* painter, QRectF* tar
}
void QGraphicsScene_Items1(QGraphicsScene* self, uintptr_t order, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(static_cast<Qt::SortOrder>(order));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(static_cast<Qt::SortOrder>(order));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -583,7 +583,7 @@ void QGraphicsScene_Items1(QGraphicsScene* self, uintptr_t order, QGraphicsItem*
}
void QGraphicsScene_Items22(QGraphicsScene* self, QPointF* pos, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*pos, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*pos, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -594,7 +594,7 @@ void QGraphicsScene_Items22(QGraphicsScene* self, QPointF* pos, uintptr_t mode,
}
void QGraphicsScene_Items3(QGraphicsScene* self, QPointF* pos, uintptr_t mode, uintptr_t order, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*pos, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*pos, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -605,7 +605,7 @@ void QGraphicsScene_Items3(QGraphicsScene* self, QPointF* pos, uintptr_t mode, u
}
void QGraphicsScene_Items4(QGraphicsScene* self, QPointF* pos, uintptr_t mode, uintptr_t order, QTransform* deviceTransform, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*pos, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*pos, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -616,7 +616,7 @@ void QGraphicsScene_Items4(QGraphicsScene* self, QPointF* pos, uintptr_t mode, u
}
void QGraphicsScene_Items23(QGraphicsScene* self, QRectF* rect, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*rect, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*rect, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -627,7 +627,7 @@ void QGraphicsScene_Items23(QGraphicsScene* self, QRectF* rect, uintptr_t mode,
}
void QGraphicsScene_Items32(QGraphicsScene* self, QRectF* rect, uintptr_t mode, uintptr_t order, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*rect, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*rect, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -638,7 +638,7 @@ void QGraphicsScene_Items32(QGraphicsScene* self, QRectF* rect, uintptr_t mode,
}
void QGraphicsScene_Items42(QGraphicsScene* self, QRectF* rect, uintptr_t mode, uintptr_t order, QTransform* deviceTransform, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*rect, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*rect, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -649,7 +649,7 @@ void QGraphicsScene_Items42(QGraphicsScene* self, QRectF* rect, uintptr_t mode,
}
void QGraphicsScene_Items25(QGraphicsScene* self, QPainterPath* path, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*path, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*path, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -660,7 +660,7 @@ void QGraphicsScene_Items25(QGraphicsScene* self, QPainterPath* path, uintptr_t
}
void QGraphicsScene_Items34(QGraphicsScene* self, QPainterPath* path, uintptr_t mode, uintptr_t order, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*path, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*path, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -671,7 +671,7 @@ void QGraphicsScene_Items34(QGraphicsScene* self, QPainterPath* path, uintptr_t
}
void QGraphicsScene_Items44(QGraphicsScene* self, QPainterPath* path, uintptr_t mode, uintptr_t order, QTransform* deviceTransform, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*path, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(*path, static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -682,7 +682,7 @@ void QGraphicsScene_Items44(QGraphicsScene* self, QPainterPath* path, uintptr_t
}
void QGraphicsScene_CollidingItems2(QGraphicsScene* self, QGraphicsItem* item, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->collidingItems(item, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->collidingItems(item, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -693,7 +693,7 @@ void QGraphicsScene_CollidingItems2(QGraphicsScene* self, QGraphicsItem* item, u
}
void QGraphicsScene_Items7(QGraphicsScene* self, double x, double y, double w, double h, uintptr_t mode, uintptr_t order, QTransform* deviceTransform, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(static_cast<qreal>(x), static_cast<qreal>(y), static_cast<qreal>(w), static_cast<qreal>(h), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
QList<QGraphicsItem*> ret = const_cast<const QGraphicsScene*>(self)->items(static_cast<qreal>(x), static_cast<qreal>(y), static_cast<qreal>(w), static_cast<qreal>(h), static_cast<Qt::ItemSelectionMode>(mode), static_cast<Qt::SortOrder>(order), *deviceTransform);
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

6
qt/gen_qgraphicsview.cpp
View File

@ -557,7 +557,7 @@ void QGraphicsView_Render4(QGraphicsView* self, QPainter* painter, QRectF* targe
}
void QGraphicsView_Items22(QGraphicsView* self, QRect* rect, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*rect, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsView*>(self)->items(*rect, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -568,7 +568,7 @@ void QGraphicsView_Items22(QGraphicsView* self, QRect* rect, uintptr_t mode, QGr
}
void QGraphicsView_Items5(QGraphicsView* self, int x, int y, int w, int h, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsView*>(self)->items(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -579,7 +579,7 @@ void QGraphicsView_Items5(QGraphicsView* self, int x, int y, int w, int h, uintp
}
void QGraphicsView_Items24(QGraphicsView* self, QPainterPath* path, uintptr_t mode, QGraphicsItem*** _out, size_t* _out_len) {
QList<QGraphicsItem*> ret = self->items(*path, static_cast<Qt::ItemSelectionMode>(mode));
QList<QGraphicsItem*> ret = const_cast<const QGraphicsView*>(self)->items(*path, static_cast<Qt::ItemSelectionMode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory
QGraphicsItem** __out = static_cast<QGraphicsItem**>(malloc(sizeof(QGraphicsItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

6
qt/gen_qgroupbox.cpp
View File

@ -110,6 +110,12 @@ void QGroupBox_Clicked(QGroupBox* self) {
self->clicked();
}
void QGroupBox_connect_Clicked(QGroupBox* self, void* slot) {
QGroupBox::connect(self, static_cast<void (QGroupBox::*)(bool)>(&QGroupBox::clicked), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
void QGroupBox_Toggled(QGroupBox* self, bool param1) {
self->toggled(param1);
}

8
qt/gen_qgroupbox.go
View File

@ -158,6 +158,14 @@ func (this *QGroupBox) Clicked() {
C.QGroupBox_Clicked(this.h)
}
func (this *QGroupBox) OnClicked(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QGroupBox_connect_Clicked(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QGroupBox) Toggled(param1 bool) {
C.QGroupBox_Toggled(this.h, (C.bool)(param1))
}

1
qt/gen_qgroupbox.h
View File

@ -42,6 +42,7 @@ void QGroupBox_SetCheckable(QGroupBox* self, bool checkable);
bool QGroupBox_IsChecked(QGroupBox* self);
void QGroupBox_SetChecked(QGroupBox* self, bool checked);
void QGroupBox_Clicked(QGroupBox* self);
void QGroupBox_connect_Clicked(QGroupBox* self, void* slot);
void QGroupBox_Toggled(QGroupBox* self, bool param1);
void QGroupBox_connect_Toggled(QGroupBox* self, void* slot);
void QGroupBox_Tr2(const char* s, const char* c, char** _out, int* _out_Strlen);

40
qt/gen_qicon.cpp
View File

@ -243,99 +243,99 @@ void QIcon_SetFallbackThemeName(const char* name, size_t name_Strlen) {
}
QPixmap* QIcon_Pixmap22(QIcon* self, QSize* size, uintptr_t mode) {
QPixmap ret = self->pixmap(*size, static_cast<QIcon::Mode>(mode));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(*size, static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap32(QIcon* self, QSize* size, uintptr_t mode, uintptr_t state) {
QPixmap ret = self->pixmap(*size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(*size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap33(QIcon* self, int w, int h, uintptr_t mode) {
QPixmap ret = self->pixmap(static_cast<int>(w), static_cast<int>(h), static_cast<QIcon::Mode>(mode));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(static_cast<int>(w), static_cast<int>(h), static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap4(QIcon* self, int w, int h, uintptr_t mode, uintptr_t state) {
QPixmap ret = self->pixmap(static_cast<int>(w), static_cast<int>(h), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(static_cast<int>(w), static_cast<int>(h), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap23(QIcon* self, int extent, uintptr_t mode) {
QPixmap ret = self->pixmap(static_cast<int>(extent), static_cast<QIcon::Mode>(mode));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(static_cast<int>(extent), static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap34(QIcon* self, int extent, uintptr_t mode, uintptr_t state) {
QPixmap ret = self->pixmap(static_cast<int>(extent), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(static_cast<int>(extent), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap35(QIcon* self, QWindow* window, QSize* size, uintptr_t mode) {
QPixmap ret = self->pixmap(window, *size, static_cast<QIcon::Mode>(mode));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(window, *size, static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QIcon_Pixmap42(QIcon* self, QWindow* window, QSize* size, uintptr_t mode, uintptr_t state) {
QPixmap ret = self->pixmap(window, *size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QPixmap ret = const_cast<const QIcon*>(self)->pixmap(window, *size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QSize* QIcon_ActualSize22(QIcon* self, QSize* size, uintptr_t mode) {
QSize ret = self->actualSize(*size, static_cast<QIcon::Mode>(mode));
QSize ret = const_cast<const QIcon*>(self)->actualSize(*size, static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
QSize* QIcon_ActualSize3(QIcon* self, QSize* size, uintptr_t mode, uintptr_t state) {
QSize ret = self->actualSize(*size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QSize ret = const_cast<const QIcon*>(self)->actualSize(*size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
QSize* QIcon_ActualSize32(QIcon* self, QWindow* window, QSize* size, uintptr_t mode) {
QSize ret = self->actualSize(window, *size, static_cast<QIcon::Mode>(mode));
QSize ret = const_cast<const QIcon*>(self)->actualSize(window, *size, static_cast<QIcon::Mode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
QSize* QIcon_ActualSize4(QIcon* self, QWindow* window, QSize* size, uintptr_t mode, uintptr_t state) {
QSize ret = self->actualSize(window, *size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QSize ret = const_cast<const QIcon*>(self)->actualSize(window, *size, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
void QIcon_Paint3(QIcon* self, QPainter* painter, QRect* rect, int alignment) {
self->paint(painter, *rect, static_cast<Qt::Alignment>(alignment));
const_cast<const QIcon*>(self)->paint(painter, *rect, static_cast<Qt::Alignment>(alignment));
}
void QIcon_Paint4(QIcon* self, QPainter* painter, QRect* rect, int alignment, uintptr_t mode) {
self->paint(painter, *rect, static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode));
const_cast<const QIcon*>(self)->paint(painter, *rect, static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode));
}
void QIcon_Paint5(QIcon* self, QPainter* painter, QRect* rect, int alignment, uintptr_t mode, uintptr_t state) {
self->paint(painter, *rect, static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
const_cast<const QIcon*>(self)->paint(painter, *rect, static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIcon_Paint6(QIcon* self, QPainter* painter, int x, int y, int w, int h, int alignment) {
self->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment));
const_cast<const QIcon*>(self)->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment));
}
void QIcon_Paint7(QIcon* self, QPainter* painter, int x, int y, int w, int h, int alignment, uintptr_t mode) {
self->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode));
const_cast<const QIcon*>(self)->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode));
}
void QIcon_Paint8(QIcon* self, QPainter* painter, int x, int y, int w, int h, int alignment, uintptr_t mode, uintptr_t state) {
self->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
const_cast<const QIcon*>(self)->paint(painter, static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h), static_cast<Qt::Alignment>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}
void QIcon_AddPixmap2(QIcon* self, QPixmap* pixmap, uintptr_t mode) {
@ -362,7 +362,7 @@ void QIcon_AddFile4(QIcon* self, const char* fileName, size_t fileName_Strlen, Q
}
void QIcon_AvailableSizes1(QIcon* self, uintptr_t mode, QSize*** _out, size_t* _out_len) {
QList<QSize> ret = self->availableSizes(static_cast<QIcon::Mode>(mode));
QList<QSize> ret = const_cast<const QIcon*>(self)->availableSizes(static_cast<QIcon::Mode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QSize** __out = static_cast<QSize**>(malloc(sizeof(QSize**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -373,7 +373,7 @@ void QIcon_AvailableSizes1(QIcon* self, uintptr_t mode, QSize*** _out, size_t* _
}
void QIcon_AvailableSizes2(QIcon* self, uintptr_t mode, uintptr_t state, QSize*** _out, size_t* _out_len) {
QList<QSize> ret = self->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QList<QSize> ret = const_cast<const QIcon*>(self)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QSize** __out = static_cast<QSize**>(malloc(sizeof(QSize**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

4
qt/gen_qiconengine.cpp
View File

@ -95,7 +95,7 @@ QPixmap* QIconEngine_ScaledPixmap(QIconEngine* self, QSize* size, uintptr_t mode
}
void QIconEngine_AvailableSizes1(QIconEngine* self, uintptr_t mode, QSize*** _out, size_t* _out_len) {
QList<QSize> ret = self->availableSizes(static_cast<QIcon::Mode>(mode));
QList<QSize> ret = const_cast<const QIconEngine*>(self)->availableSizes(static_cast<QIcon::Mode>(mode));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QSize** __out = static_cast<QSize**>(malloc(sizeof(QSize**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -106,7 +106,7 @@ void QIconEngine_AvailableSizes1(QIconEngine* self, uintptr_t mode, QSize*** _ou
}
void QIconEngine_AvailableSizes2(QIconEngine* self, uintptr_t mode, uintptr_t state, QSize*** _out, size_t* _out_len) {
QList<QSize> ret = self->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
QList<QSize> ret = const_cast<const QIconEngine*>(self)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QSize** __out = static_cast<QSize**>(malloc(sizeof(QSize**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

12
qt/gen_qidentityproxymodel.cpp
View File

@ -171,27 +171,27 @@ void QIdentityProxyModel_TrUtf83(const char* s, const char* c, int n, char** _ou
}
int QIdentityProxyModel_ColumnCount1(QIdentityProxyModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QIdentityProxyModel*>(self)->columnCount(*parent);
}
QModelIndex* QIdentityProxyModel_Index3(QIdentityProxyModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QIdentityProxyModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QIdentityProxyModel_RowCount1(QIdentityProxyModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QIdentityProxyModel*>(self)->rowCount(*parent);
}
QVariant* QIdentityProxyModel_HeaderData3(QIdentityProxyModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QIdentityProxyModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
void QIdentityProxyModel_Match4(QIdentityProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
QModelIndexList ret = const_cast<const QIdentityProxyModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -202,7 +202,7 @@ void QIdentityProxyModel_Match4(QIdentityProxyModel* self, QModelIndex* start, i
}
void QIdentityProxyModel_Match5(QIdentityProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
QModelIndexList ret = const_cast<const QIdentityProxyModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

42
qt/gen_qimage.cpp
View File

@ -561,13 +561,13 @@ uintptr_t QImage_ToImageFormat(QPixelFormat* format) {
}
QImage* QImage_Copy1(QImage* self, QRect* rect) {
QImage ret = self->copy(*rect);
QImage ret = const_cast<const QImage*>(self)->copy(*rect);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_ConvertToFormat22(QImage* self, uintptr_t f, int flags) {
QImage ret = self->convertToFormat(static_cast<QImage::Format>(f), static_cast<Qt::ImageConversionFlags>(flags));
QImage ret = const_cast<const QImage*>(self)->convertToFormat(static_cast<QImage::Format>(f), static_cast<Qt::ImageConversionFlags>(flags));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
@ -578,7 +578,7 @@ QImage* QImage_ConvertToFormat3(QImage* self, uintptr_t f, unsigned int* colorTa
for(size_t i = 0; i < colorTable_len; ++i) {
colorTable_QList.push_back(colorTable[i]);
}
QImage ret = self->convertToFormat(static_cast<QImage::Format>(f), colorTable_QList, static_cast<Qt::ImageConversionFlags>(flags));
QImage ret = const_cast<const QImage*>(self)->convertToFormat(static_cast<QImage::Format>(f), colorTable_QList, static_cast<Qt::ImageConversionFlags>(flags));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
@ -588,79 +588,79 @@ void QImage_ConvertTo2(QImage* self, uintptr_t f, int flags) {
}
QImage* QImage_CreateAlphaMask1(QImage* self, int flags) {
QImage ret = self->createAlphaMask(static_cast<Qt::ImageConversionFlags>(flags));
QImage ret = const_cast<const QImage*>(self)->createAlphaMask(static_cast<Qt::ImageConversionFlags>(flags));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_CreateHeuristicMask1(QImage* self, bool clipTight) {
QImage ret = self->createHeuristicMask(clipTight);
QImage ret = const_cast<const QImage*>(self)->createHeuristicMask(clipTight);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_CreateMaskFromColor2(QImage* self, unsigned int color, uintptr_t mode) {
QImage ret = self->createMaskFromColor(static_cast<QRgb>(color), static_cast<Qt::MaskMode>(mode));
QImage ret = const_cast<const QImage*>(self)->createMaskFromColor(static_cast<QRgb>(color), static_cast<Qt::MaskMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Scaled3(QImage* self, int w, int h, uintptr_t aspectMode) {
QImage ret = self->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode));
QImage ret = const_cast<const QImage*>(self)->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Scaled4(QImage* self, int w, int h, uintptr_t aspectMode, uintptr_t mode) {
QImage ret = self->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Scaled2(QImage* self, QSize* s, uintptr_t aspectMode) {
QImage ret = self->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode));
QImage ret = const_cast<const QImage*>(self)->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Scaled32(QImage* self, QSize* s, uintptr_t aspectMode, uintptr_t mode) {
QImage ret = self->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_ScaledToWidth2(QImage* self, int w, uintptr_t mode) {
QImage ret = self->scaledToWidth(static_cast<int>(w), static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->scaledToWidth(static_cast<int>(w), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_ScaledToHeight2(QImage* self, int h, uintptr_t mode) {
QImage ret = self->scaledToHeight(static_cast<int>(h), static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->scaledToHeight(static_cast<int>(h), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Transformed2(QImage* self, QMatrix* matrix, uintptr_t mode) {
QImage ret = self->transformed(*matrix, static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->transformed(*matrix, static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Transformed22(QImage* self, QTransform* matrix, uintptr_t mode) {
QImage ret = self->transformed(*matrix, static_cast<Qt::TransformationMode>(mode));
QImage ret = const_cast<const QImage*>(self)->transformed(*matrix, static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Mirrored1(QImage* self, bool horizontally) {
QImage ret = self->mirrored(horizontally);
QImage ret = const_cast<const QImage*>(self)->mirrored(horizontally);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QImage_Mirrored2(QImage* self, bool horizontally, bool vertically) {
QImage ret = self->mirrored(horizontally, vertically);
QImage ret = const_cast<const QImage*>(self)->mirrored(horizontally, vertically);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
@ -684,20 +684,20 @@ bool QImage_LoadFromData2(QImage* self, QByteArray* data, const char* aformat) {
bool QImage_Save2(QImage* self, const char* fileName, size_t fileName_Strlen, const char* format) {
QString fileName_QString = QString::fromUtf8(fileName, fileName_Strlen);
return self->save(fileName_QString, format);
return const_cast<const QImage*>(self)->save(fileName_QString, format);
}
bool QImage_Save3(QImage* self, const char* fileName, size_t fileName_Strlen, const char* format, int quality) {
QString fileName_QString = QString::fromUtf8(fileName, fileName_Strlen);
return self->save(fileName_QString, format, static_cast<int>(quality));
return const_cast<const QImage*>(self)->save(fileName_QString, format, static_cast<int>(quality));
}
bool QImage_Save22(QImage* self, QIODevice* device, const char* format) {
return self->save(device, format);
return const_cast<const QImage*>(self)->save(device, format);
}
bool QImage_Save32(QImage* self, QIODevice* device, const char* format, int quality) {
return self->save(device, format, static_cast<int>(quality));
return const_cast<const QImage*>(self)->save(device, format, static_cast<int>(quality));
}
QImage* QImage_FromData3(const unsigned char* data, int size, const char* format) {
@ -714,7 +714,7 @@ QImage* QImage_FromData2(QByteArray* data, const char* format) {
void QImage_Text1(QImage* self, const char* key, size_t key_Strlen, char** _out, int* _out_Strlen) {
QString key_QString = QString::fromUtf8(key, key_Strlen);
QString ret = self->text(key_QString);
QString ret = const_cast<const QImage*>(self)->text(key_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

2
qt/gen_qimageiohandler.cpp
View File

@ -173,7 +173,7 @@ void QImageIOPlugin_TrUtf83(const char* s, const char* c, int n, char** _out, in
}
QImageIOHandler* QImageIOPlugin_Create2(QImageIOPlugin* self, QIODevice* device, QByteArray* format) {
return self->create(device, *format);
return const_cast<const QImageIOPlugin*>(self)->create(device, *format);
}
void QImageIOPlugin_Delete(QImageIOPlugin* self) {

12
qt/gen_qitemselectionmodel.cpp
View File

@ -350,23 +350,23 @@ void QItemSelectionModel_TrUtf83(const char* s, const char* c, int n, char** _ou
}
bool QItemSelectionModel_IsRowSelected2(QItemSelectionModel* self, int row, QModelIndex* parent) {
return self->isRowSelected(static_cast<int>(row), *parent);
return const_cast<const QItemSelectionModel*>(self)->isRowSelected(static_cast<int>(row), *parent);
}
bool QItemSelectionModel_IsColumnSelected2(QItemSelectionModel* self, int column, QModelIndex* parent) {
return self->isColumnSelected(static_cast<int>(column), *parent);
return const_cast<const QItemSelectionModel*>(self)->isColumnSelected(static_cast<int>(column), *parent);
}
bool QItemSelectionModel_RowIntersectsSelection2(QItemSelectionModel* self, int row, QModelIndex* parent) {
return self->rowIntersectsSelection(static_cast<int>(row), *parent);
return const_cast<const QItemSelectionModel*>(self)->rowIntersectsSelection(static_cast<int>(row), *parent);
}
bool QItemSelectionModel_ColumnIntersectsSelection2(QItemSelectionModel* self, int column, QModelIndex* parent) {
return self->columnIntersectsSelection(static_cast<int>(column), *parent);
return const_cast<const QItemSelectionModel*>(self)->columnIntersectsSelection(static_cast<int>(column), *parent);
}
void QItemSelectionModel_SelectedRows1(QItemSelectionModel* self, int column, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->selectedRows(static_cast<int>(column));
QModelIndexList ret = const_cast<const QItemSelectionModel*>(self)->selectedRows(static_cast<int>(column));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -377,7 +377,7 @@ void QItemSelectionModel_SelectedRows1(QItemSelectionModel* self, int column, QM
}
void QItemSelectionModel_SelectedColumns1(QItemSelectionModel* self, int row, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->selectedColumns(static_cast<int>(row));
QModelIndexList ret = const_cast<const QItemSelectionModel*>(self)->selectedColumns(static_cast<int>(row));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

6
qt/gen_qjsonvalue.cpp
View File

@ -191,15 +191,15 @@ bool QJsonValue_OperatorNotEqual(QJsonValue* self, QJsonValue* other) {
}
bool QJsonValue_ToBool1(QJsonValue* self, bool defaultValue) {
return self->toBool(defaultValue);
return const_cast<const QJsonValue*>(self)->toBool(defaultValue);
}
int QJsonValue_ToInt1(QJsonValue* self, int defaultValue) {
return self->toInt(static_cast<int>(defaultValue));
return const_cast<const QJsonValue*>(self)->toInt(static_cast<int>(defaultValue));
}
double QJsonValue_ToDouble1(QJsonValue* self, double defaultValue) {
return self->toDouble(static_cast<double>(defaultValue));
return const_cast<const QJsonValue*>(self)->toDouble(static_cast<double>(defaultValue));
}
void QJsonValue_Delete(QJsonValue* self) {

2
qt/gen_qkeysequence.cpp
View File

@ -163,7 +163,7 @@ bool QKeySequence_IsDetached(QKeySequence* self) {
}
void QKeySequence_ToString1(QKeySequence* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<QKeySequence::SequenceFormat>(format));
QString ret = const_cast<const QKeySequence*>(self)->toString(static_cast<QKeySequence::SequenceFormat>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

90
qt/gen_qlocale.cpp
View File

@ -589,8 +589,8 @@ void QLocale_CurrencySymbol(QLocale* self, char** _out, int* _out_Strlen) {
*_out_Strlen = b.length();
}
void QLocale_ToCurrencyString(QLocale* self, int64_t param1, char** _out, int* _out_Strlen) {
QString ret = const_cast<const QLocale*>(self)->toCurrencyString((qlonglong)(param1));
void QLocale_ToCurrencyString(QLocale* self, long long param1, char** _out, int* _out_Strlen) {
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<qint64>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -598,8 +598,8 @@ void QLocale_ToCurrencyString(QLocale* self, int64_t param1, char** _out, int* _
*_out_Strlen = b.length();
}
void QLocale_ToCurrencyStringWithQulonglong(QLocale* self, uint64_t param1, char** _out, int* _out_Strlen) {
QString ret = const_cast<const QLocale*>(self)->toCurrencyString((qulonglong)(param1));
void QLocale_ToCurrencyStringWithQulonglong(QLocale* self, unsigned long long param1, char** _out, int* _out_Strlen) {
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<quint64>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -824,56 +824,56 @@ void QLocale_CreateSeparatedList(QLocale* self, char** strl, uint64_t* strl_Leng
int16_t QLocale_ToShort2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toShort(s_QString, ok);
return const_cast<const QLocale*>(self)->toShort(s_QString, ok);
}
uint16_t QLocale_ToUShort2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toUShort(s_QString, ok);
return const_cast<const QLocale*>(self)->toUShort(s_QString, ok);
}
int QLocale_ToInt2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toInt(s_QString, ok);
return const_cast<const QLocale*>(self)->toInt(s_QString, ok);
}
unsigned int QLocale_ToUInt2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toUInt(s_QString, ok);
return const_cast<const QLocale*>(self)->toUInt(s_QString, ok);
}
long QLocale_ToLong2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toLong(s_QString, ok);
return const_cast<const QLocale*>(self)->toLong(s_QString, ok);
}
unsigned long QLocale_ToULong2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toULong(s_QString, ok);
return const_cast<const QLocale*>(self)->toULong(s_QString, ok);
}
int64_t QLocale_ToLongLong2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toLongLong(s_QString, ok);
return const_cast<const QLocale*>(self)->toLongLong(s_QString, ok);
}
uint64_t QLocale_ToULongLong2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toULongLong(s_QString, ok);
return const_cast<const QLocale*>(self)->toULongLong(s_QString, ok);
}
float QLocale_ToFloat2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toFloat(s_QString, ok);
return const_cast<const QLocale*>(self)->toFloat(s_QString, ok);
}
double QLocale_ToDouble2(QLocale* self, const char* s, size_t s_Strlen, bool* ok) {
QString s_QString = QString::fromUtf8(s, s_Strlen);
return self->toDouble(s_QString, ok);
return const_cast<const QLocale*>(self)->toDouble(s_QString, ok);
}
void QLocale_ToString22(QLocale* self, double i, char f, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<double>(i), static_cast<char>(f));
QString ret = const_cast<const QLocale*>(self)->toString(static_cast<double>(i), static_cast<char>(f));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -882,7 +882,7 @@ void QLocale_ToString22(QLocale* self, double i, char f, char** _out, int* _out_
}
void QLocale_ToString32(QLocale* self, double i, char f, int prec, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<double>(i), static_cast<char>(f), static_cast<int>(prec));
QString ret = const_cast<const QLocale*>(self)->toString(static_cast<double>(i), static_cast<char>(f), static_cast<int>(prec));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -891,7 +891,7 @@ void QLocale_ToString32(QLocale* self, double i, char f, int prec, char** _out,
}
void QLocale_ToString23(QLocale* self, float i, char f, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<float>(i), static_cast<char>(f));
QString ret = const_cast<const QLocale*>(self)->toString(static_cast<float>(i), static_cast<char>(f));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -900,7 +900,7 @@ void QLocale_ToString23(QLocale* self, float i, char f, char** _out, int* _out_S
}
void QLocale_ToString33(QLocale* self, float i, char f, int prec, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<float>(i), static_cast<char>(f), static_cast<int>(prec));
QString ret = const_cast<const QLocale*>(self)->toString(static_cast<float>(i), static_cast<char>(f), static_cast<int>(prec));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -909,7 +909,7 @@ void QLocale_ToString33(QLocale* self, float i, char f, int prec, char** _out, i
}
void QLocale_ToString24(QLocale* self, QDate* date, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(*date, static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->toString(*date, static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -918,7 +918,7 @@ void QLocale_ToString24(QLocale* self, QDate* date, uintptr_t format, char** _ou
}
void QLocale_ToString25(QLocale* self, QTime* time, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(*time, static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->toString(*time, static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -927,7 +927,7 @@ void QLocale_ToString25(QLocale* self, QTime* time, uintptr_t format, char** _ou
}
void QLocale_ToString26(QLocale* self, QDateTime* dateTime, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->toString(*dateTime, static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->toString(*dateTime, static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -936,7 +936,7 @@ void QLocale_ToString26(QLocale* self, QDateTime* dateTime, uintptr_t format, ch
}
void QLocale_DateFormat1(QLocale* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->dateFormat(static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->dateFormat(static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -945,7 +945,7 @@ void QLocale_DateFormat1(QLocale* self, uintptr_t format, char** _out, int* _out
}
void QLocale_TimeFormat1(QLocale* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->timeFormat(static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->timeFormat(static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -954,7 +954,7 @@ void QLocale_TimeFormat1(QLocale* self, uintptr_t format, char** _out, int* _out
}
void QLocale_DateTimeFormat1(QLocale* self, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->dateTimeFormat(static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->dateTimeFormat(static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -964,27 +964,27 @@ void QLocale_DateTimeFormat1(QLocale* self, uintptr_t format, char** _out, int*
QDate* QLocale_ToDate22(QLocale* self, const char* stringVal, size_t stringVal_Strlen, uintptr_t param2) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
QDate ret = self->toDate(stringVal_QString, static_cast<QLocale::FormatType>(param2));
QDate ret = const_cast<const QLocale*>(self)->toDate(stringVal_QString, static_cast<QLocale::FormatType>(param2));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDate*>(new QDate(ret));
}
QTime* QLocale_ToTime22(QLocale* self, const char* stringVal, size_t stringVal_Strlen, uintptr_t param2) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
QTime ret = self->toTime(stringVal_QString, static_cast<QLocale::FormatType>(param2));
QTime ret = const_cast<const QLocale*>(self)->toTime(stringVal_QString, static_cast<QLocale::FormatType>(param2));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTime*>(new QTime(ret));
}
QDateTime* QLocale_ToDateTime22(QLocale* self, const char* stringVal, size_t stringVal_Strlen, uintptr_t format) {
QString stringVal_QString = QString::fromUtf8(stringVal, stringVal_Strlen);
QDateTime ret = self->toDateTime(stringVal_QString, static_cast<QLocale::FormatType>(format));
QDateTime ret = const_cast<const QLocale*>(self)->toDateTime(stringVal_QString, static_cast<QLocale::FormatType>(format));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QDateTime*>(new QDateTime(ret));
}
void QLocale_MonthName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->monthName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->monthName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -993,7 +993,7 @@ void QLocale_MonthName2(QLocale* self, int param1, uintptr_t format, char** _out
}
void QLocale_StandaloneMonthName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->standaloneMonthName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->standaloneMonthName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1002,7 +1002,7 @@ void QLocale_StandaloneMonthName2(QLocale* self, int param1, uintptr_t format, c
}
void QLocale_DayName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->dayName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->dayName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1011,7 +1011,7 @@ void QLocale_DayName2(QLocale* self, int param1, uintptr_t format, char** _out,
}
void QLocale_StandaloneDayName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen) {
QString ret = self->standaloneDayName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
QString ret = const_cast<const QLocale*>(self)->standaloneDayName(static_cast<int>(param1), static_cast<QLocale::FormatType>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1020,7 +1020,7 @@ void QLocale_StandaloneDayName2(QLocale* self, int param1, uintptr_t format, cha
}
void QLocale_CurrencySymbol1(QLocale* self, uintptr_t param1, char** _out, int* _out_Strlen) {
QString ret = self->currencySymbol(static_cast<QLocale::CurrencySymbolFormat>(param1));
QString ret = const_cast<const QLocale*>(self)->currencySymbol(static_cast<QLocale::CurrencySymbolFormat>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1028,9 +1028,9 @@ void QLocale_CurrencySymbol1(QLocale* self, uintptr_t param1, char** _out, int*
*_out_Strlen = b.length();
}
void QLocale_ToCurrencyString22(QLocale* self, int64_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
void QLocale_ToCurrencyString22(QLocale* self, long long param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString((qlonglong)(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<qint64>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1038,9 +1038,9 @@ void QLocale_ToCurrencyString22(QLocale* self, int64_t param1, const char* symbo
*_out_Strlen = b.length();
}
void QLocale_ToCurrencyString23(QLocale* self, uint64_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
void QLocale_ToCurrencyString23(QLocale* self, unsigned long long param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString((qulonglong)(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<quint64>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1050,7 +1050,7 @@ void QLocale_ToCurrencyString23(QLocale* self, uint64_t param1, const char* symb
void QLocale_ToCurrencyString24(QLocale* self, int16_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<short>(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<short>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1060,7 +1060,7 @@ void QLocale_ToCurrencyString24(QLocale* self, int16_t param1, const char* symbo
void QLocale_ToCurrencyString25(QLocale* self, uint16_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<ushort>(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<ushort>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1070,7 +1070,7 @@ void QLocale_ToCurrencyString25(QLocale* self, uint16_t param1, const char* symb
void QLocale_ToCurrencyString26(QLocale* self, int param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<int>(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<int>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1080,7 +1080,7 @@ void QLocale_ToCurrencyString26(QLocale* self, int param1, const char* symbol, s
void QLocale_ToCurrencyString27(QLocale* self, unsigned int param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<uint>(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<uint>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1090,7 +1090,7 @@ void QLocale_ToCurrencyString27(QLocale* self, unsigned int param1, const char*
void QLocale_ToCurrencyString28(QLocale* self, double param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<double>(param1), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<double>(param1), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1100,7 +1100,7 @@ void QLocale_ToCurrencyString28(QLocale* self, double param1, const char* symbol
void QLocale_ToCurrencyString29(QLocale* self, float i, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen) {
QString symbol_QString = QString::fromUtf8(symbol, symbol_Strlen);
QString ret = self->toCurrencyString(static_cast<float>(i), symbol_QString);
QString ret = const_cast<const QLocale*>(self)->toCurrencyString(static_cast<float>(i), symbol_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1127,7 +1127,7 @@ void QLocale_FormattedDataSize3(QLocale* self, long long bytes, int precision, i
}
void QLocale_FormattedDataSize22(QLocale* self, long long bytes, int precision, char** _out, int* _out_Strlen) {
QString ret = self->formattedDataSize(static_cast<qint64>(bytes), static_cast<int>(precision));
QString ret = const_cast<const QLocale*>(self)->formattedDataSize(static_cast<qint64>(bytes), static_cast<int>(precision));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1136,7 +1136,7 @@ void QLocale_FormattedDataSize22(QLocale* self, long long bytes, int precision,
}
void QLocale_FormattedDataSize32(QLocale* self, long long bytes, int precision, int format, char** _out, int* _out_Strlen) {
QString ret = self->formattedDataSize(static_cast<qint64>(bytes), static_cast<int>(precision), static_cast<QLocale::DataSizeFormats>(format));
QString ret = const_cast<const QLocale*>(self)->formattedDataSize(static_cast<qint64>(bytes), static_cast<int>(precision), static_cast<QLocale::DataSizeFormats>(format));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -1146,7 +1146,7 @@ void QLocale_FormattedDataSize32(QLocale* self, long long bytes, int precision,
void QLocale_QuoteString2(QLocale* self, const char* str, size_t str_Strlen, uintptr_t style, char** _out, int* _out_Strlen) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
QString ret = self->quoteString(str_QString, static_cast<QLocale::QuotationStyle>(style));
QString ret = const_cast<const QLocale*>(self)->quoteString(str_QString, static_cast<QLocale::QuotationStyle>(style));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

8
qt/gen_qlocale.go
View File

@ -1647,7 +1647,7 @@ func (this *QLocale) CurrencySymbol() string {
func (this *QLocale) ToCurrencyString(param1 int64) string {
var _out *C.char = nil
var _out_Strlen C.int = 0
C.QLocale_ToCurrencyString(this.h, (C.int64_t)(param1), &_out, &_out_Strlen)
C.QLocale_ToCurrencyString(this.h, (C.longlong)(param1), &_out, &_out_Strlen)
ret := C.GoStringN(_out, _out_Strlen)
C.free(unsafe.Pointer(_out))
return ret
@ -1656,7 +1656,7 @@ func (this *QLocale) ToCurrencyString(param1 int64) string {
func (this *QLocale) ToCurrencyStringWithQulonglong(param1 uint64) string {
var _out *C.char = nil
var _out_Strlen C.int = 0
C.QLocale_ToCurrencyStringWithQulonglong(this.h, (C.uint64_t)(param1), &_out, &_out_Strlen)
C.QLocale_ToCurrencyStringWithQulonglong(this.h, (C.ulonglong)(param1), &_out, &_out_Strlen)
ret := C.GoStringN(_out, _out_Strlen)
C.free(unsafe.Pointer(_out))
return ret
@ -2149,7 +2149,7 @@ func (this *QLocale) ToCurrencyString22(param1 int64, symbol string) string {
defer C.free(unsafe.Pointer(symbol_Cstring))
var _out *C.char = nil
var _out_Strlen C.int = 0
C.QLocale_ToCurrencyString22(this.h, (C.int64_t)(param1), symbol_Cstring, C.size_t(len(symbol)), &_out, &_out_Strlen)
C.QLocale_ToCurrencyString22(this.h, (C.longlong)(param1), symbol_Cstring, C.size_t(len(symbol)), &_out, &_out_Strlen)
ret := C.GoStringN(_out, _out_Strlen)
C.free(unsafe.Pointer(_out))
return ret
@ -2160,7 +2160,7 @@ func (this *QLocale) ToCurrencyString23(param1 uint64, symbol string) string {
defer C.free(unsafe.Pointer(symbol_Cstring))
var _out *C.char = nil
var _out_Strlen C.int = 0
C.QLocale_ToCurrencyString23(this.h, (C.uint64_t)(param1), symbol_Cstring, C.size_t(len(symbol)), &_out, &_out_Strlen)
C.QLocale_ToCurrencyString23(this.h, (C.ulonglong)(param1), symbol_Cstring, C.size_t(len(symbol)), &_out, &_out_Strlen)
ret := C.GoStringN(_out, _out_Strlen)
C.free(unsafe.Pointer(_out))
return ret

8
qt/gen_qlocale.h
View File

@ -106,8 +106,8 @@ uintptr_t QLocale_TextDirection(QLocale* self);
void QLocale_ToUpper(QLocale* self, const char* str, size_t str_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToLower(QLocale* self, const char* str, size_t str_Strlen, char** _out, int* _out_Strlen);
void QLocale_CurrencySymbol(QLocale* self, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString(QLocale* self, int64_t param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyStringWithQulonglong(QLocale* self, uint64_t param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString(QLocale* self, long long param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyStringWithQulonglong(QLocale* self, unsigned long long param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyStringWithShort(QLocale* self, int16_t param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyStringWithUshort(QLocale* self, uint16_t param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyStringWithInt(QLocale* self, int param1, char** _out, int* _out_Strlen);
@ -161,8 +161,8 @@ void QLocale_StandaloneMonthName2(QLocale* self, int param1, uintptr_t format, c
void QLocale_DayName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen);
void QLocale_StandaloneDayName2(QLocale* self, int param1, uintptr_t format, char** _out, int* _out_Strlen);
void QLocale_CurrencySymbol1(QLocale* self, uintptr_t param1, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString22(QLocale* self, int64_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString23(QLocale* self, uint64_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString22(QLocale* self, long long param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString23(QLocale* self, unsigned long long param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString24(QLocale* self, int16_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString25(QLocale* self, uint16_t param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);
void QLocale_ToCurrencyString26(QLocale* self, int param1, const char* symbol, size_t symbol_Strlen, char** _out, int* _out_Strlen);

2
qt/gen_qmainwindow.cpp
View File

@ -363,7 +363,7 @@ void QMainWindow_AddToolBarBreak1(QMainWindow* self, uintptr_t area) {
}
QByteArray* QMainWindow_SaveState1(QMainWindow* self, int version) {
QByteArray ret = self->saveState(static_cast<int>(version));
QByteArray ret = const_cast<const QMainWindow*>(self)->saveState(static_cast<int>(version));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}

2
qt/gen_qmatrix.cpp
View File

@ -186,7 +186,7 @@ QMatrix* QMatrix_OperatorMultiply(QMatrix* self, QMatrix* o) {
}
QMatrix* QMatrix_Inverted1(QMatrix* self, bool* invertible) {
QMatrix ret = self->inverted(invertible);
QMatrix ret = const_cast<const QMatrix*>(self)->inverted(invertible);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QMatrix*>(new QMatrix(ret));
}

2
qt/gen_qmatrix4x4.cpp
View File

@ -295,7 +295,7 @@ void QMatrix4x4_Optimize(QMatrix4x4* self) {
}
QMatrix4x4* QMatrix4x4_Inverted1(QMatrix4x4* self, bool* invertible) {
QMatrix4x4 ret = self->inverted(invertible);
QMatrix4x4 ret = const_cast<const QMatrix4x4*>(self)->inverted(invertible);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QMatrix4x4*>(new QMatrix4x4(ret));
}

2
qt/gen_qmdiarea.cpp
View File

@ -238,7 +238,7 @@ void QMdiArea_TrUtf83(const char* s, const char* c, int n, char** _out, int* _ou
}
void QMdiArea_SubWindowList1(QMdiArea* self, uintptr_t order, QMdiSubWindow*** _out, size_t* _out_len) {
QList<QMdiSubWindow*> ret = self->subWindowList(static_cast<QMdiArea::WindowOrder>(order));
QList<QMdiSubWindow*> ret = const_cast<const QMdiArea*>(self)->subWindowList(static_cast<QMdiArea::WindowOrder>(order));
// Convert QList<> from C++ memory to manually-managed C memory
QMdiSubWindow** __out = static_cast<QMdiSubWindow**>(malloc(sizeof(QMdiSubWindow*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

2
qt/gen_qmenubar.cpp
View File

@ -206,7 +206,7 @@ void QMenuBar_SetCornerWidget2(QMenuBar* self, QWidget* w, uintptr_t corner) {
}
QWidget* QMenuBar_CornerWidget1(QMenuBar* self, uintptr_t corner) {
return self->cornerWidget(static_cast<Qt::Corner>(corner));
return const_cast<const QMenuBar*>(self)->cornerWidget(static_cast<Qt::Corner>(corner));
}
void QMenuBar_Delete(QMenuBar* self) {

94
qt/gen_qmetaobject.cpp
View File

@ -130,163 +130,163 @@ bool QMetaMethod_IsValid(QMetaMethod* self) {
}
bool QMetaMethod_Invoke4(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0);
}
bool QMetaMethod_Invoke5(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1);
}
bool QMetaMethod_Invoke6(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2);
}
bool QMetaMethod_Invoke7(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3);
}
bool QMetaMethod_Invoke8(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4);
}
bool QMetaMethod_Invoke9(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5);
}
bool QMetaMethod_Invoke10(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
}
bool QMetaMethod_Invoke11(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
}
bool QMetaMethod_Invoke12(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
}
bool QMetaMethod_Invoke13(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8, QGenericArgument* val9) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
}
bool QMetaMethod_Invoke32(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0) {
return self->invoke(object, *returnValue, *val0);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0);
}
bool QMetaMethod_Invoke42(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1) {
return self->invoke(object, *returnValue, *val0, *val1);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1);
}
bool QMetaMethod_Invoke52(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2) {
return self->invoke(object, *returnValue, *val0, *val1, *val2);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2);
}
bool QMetaMethod_Invoke62(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3);
}
bool QMetaMethod_Invoke72(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4);
}
bool QMetaMethod_Invoke82(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5);
}
bool QMetaMethod_Invoke92(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
}
bool QMetaMethod_Invoke102(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
}
bool QMetaMethod_Invoke112(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
}
bool QMetaMethod_Invoke122(QMetaMethod* self, QObject* object, QGenericReturnArgument* returnValue, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8, QGenericArgument* val9) {
return self->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
return const_cast<const QMetaMethod*>(self)->invoke(object, *returnValue, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
}
bool QMetaMethod_Invoke33(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0);
}
bool QMetaMethod_Invoke43(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1);
}
bool QMetaMethod_Invoke53(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2);
}
bool QMetaMethod_Invoke63(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3);
}
bool QMetaMethod_Invoke73(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4);
}
bool QMetaMethod_Invoke83(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5);
}
bool QMetaMethod_Invoke93(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6);
}
bool QMetaMethod_Invoke103(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
}
bool QMetaMethod_Invoke113(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
}
bool QMetaMethod_Invoke123(QMetaMethod* self, QObject* object, uintptr_t connectionType, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8, QGenericArgument* val9) {
return self->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
return const_cast<const QMetaMethod*>(self)->invoke(object, static_cast<Qt::ConnectionType>(connectionType), *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
}
bool QMetaMethod_Invoke22(QMetaMethod* self, QObject* object, QGenericArgument* val0) {
return self->invoke(object, *val0);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0);
}
bool QMetaMethod_Invoke34(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1) {
return self->invoke(object, *val0, *val1);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1);
}
bool QMetaMethod_Invoke44(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2) {
return self->invoke(object, *val0, *val1, *val2);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2);
}
bool QMetaMethod_Invoke54(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3) {
return self->invoke(object, *val0, *val1, *val2, *val3);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3);
}
bool QMetaMethod_Invoke64(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4);
}
bool QMetaMethod_Invoke74(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5);
}
bool QMetaMethod_Invoke84(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6);
}
bool QMetaMethod_Invoke94(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
}
bool QMetaMethod_Invoke104(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
}
bool QMetaMethod_Invoke114(QMetaMethod* self, QObject* object, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8, QGenericArgument* val9) {
return self->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
return const_cast<const QMetaMethod*>(self)->invoke(object, *val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
}
void QMetaMethod_Delete(QMetaMethod* self) {
@ -360,11 +360,11 @@ bool QMetaEnum_IsValid(QMetaEnum* self) {
}
int QMetaEnum_KeyToValue2(QMetaEnum* self, const char* key, bool* ok) {
return self->keyToValue(key, ok);
return const_cast<const QMetaEnum*>(self)->keyToValue(key, ok);
}
int QMetaEnum_KeysToValue2(QMetaEnum* self, const char* keys, bool* ok) {
return self->keysToValue(keys, ok);
return const_cast<const QMetaEnum*>(self)->keysToValue(keys, ok);
}
void QMetaEnum_Delete(QMetaEnum* self) {
@ -503,23 +503,23 @@ QMetaObject* QMetaProperty_EnclosingMetaObject(QMetaProperty* self) {
}
bool QMetaProperty_IsDesignable1(QMetaProperty* self, QObject* obj) {
return self->isDesignable(obj);
return const_cast<const QMetaProperty*>(self)->isDesignable(obj);
}
bool QMetaProperty_IsScriptable1(QMetaProperty* self, QObject* obj) {
return self->isScriptable(obj);
return const_cast<const QMetaProperty*>(self)->isScriptable(obj);
}
bool QMetaProperty_IsStored1(QMetaProperty* self, QObject* obj) {
return self->isStored(obj);
return const_cast<const QMetaProperty*>(self)->isStored(obj);
}
bool QMetaProperty_IsEditable1(QMetaProperty* self, QObject* obj) {
return self->isEditable(obj);
return const_cast<const QMetaProperty*>(self)->isEditable(obj);
}
bool QMetaProperty_IsUser1(QMetaProperty* self, QObject* obj) {
return self->isUser(obj);
return const_cast<const QMetaProperty*>(self)->isUser(obj);
}
void QMetaProperty_Delete(QMetaProperty* self) {

4
qt/gen_qmimedatabase.cpp
View File

@ -107,13 +107,13 @@ void QMimeDatabase_AllMimeTypes(QMimeDatabase* self, QMimeType*** _out, size_t*
QMimeType* QMimeDatabase_MimeTypeForFile2(QMimeDatabase* self, const char* fileName, size_t fileName_Strlen, uintptr_t mode) {
QString fileName_QString = QString::fromUtf8(fileName, fileName_Strlen);
QMimeType ret = self->mimeTypeForFile(fileName_QString, static_cast<QMimeDatabase::MatchMode>(mode));
QMimeType ret = const_cast<const QMimeDatabase*>(self)->mimeTypeForFile(fileName_QString, static_cast<QMimeDatabase::MatchMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QMimeType*>(new QMimeType(ret));
}
QMimeType* QMimeDatabase_MimeTypeForFile22(QMimeDatabase* self, QFileInfo* fileInfo, uintptr_t mode) {
QMimeType ret = self->mimeTypeForFile(*fileInfo, static_cast<QMimeDatabase::MatchMode>(mode));
QMimeType ret = const_cast<const QMimeDatabase*>(self)->mimeTypeForFile(*fileInfo, static_cast<QMimeDatabase::MatchMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QMimeType*>(new QMimeType(ret));
}

8
qt/gen_qobject.cpp
View File

@ -209,6 +209,12 @@ void QObject_Destroyed(QObject* self) {
self->destroyed();
}
void QObject_connect_Destroyed(QObject* self, void* slot) {
QObject::connect(self, static_cast<void (QObject::*)(QObject*)>(&QObject::destroyed), self, [=]() {
miqt_exec_callback(slot, 0, nullptr);
});
}
QObject* QObject_Parent(QObject* self) {
return const_cast<const QObject*>(self)->parent();
}
@ -268,7 +274,7 @@ QMetaObject__Connection* QObject_Connect5(QObject* sender, QMetaMethod* signal,
}
QMetaObject__Connection* QObject_Connect4(QObject* self, QObject* sender, const char* signal, const char* member, uintptr_t typeVal) {
QMetaObject::Connection ret = self->connect(sender, signal, member, static_cast<Qt::ConnectionType>(typeVal));
QMetaObject::Connection ret = const_cast<const QObject*>(self)->connect(sender, signal, member, static_cast<Qt::ConnectionType>(typeVal));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QMetaObject::Connection*>(new QMetaObject::Connection(ret));
}

8
qt/gen_qobject.go
View File

@ -303,6 +303,14 @@ func (this *QObject) Destroyed() {
C.QObject_Destroyed(this.h)
}
func (this *QObject) OnDestroyed(slot func()) {
var slotWrapper miqtCallbackFunc = func(argc C.int, args *C.void) {
slot()
}
C.QObject_connect_Destroyed(this.h, unsafe.Pointer(uintptr(cgo.NewHandle(slotWrapper))))
}
func (this *QObject) Parent() *QObject {
ret := C.QObject_Parent(this.h)
return newQObject_U(unsafe.Pointer(ret))

1
qt/gen_qobject.h
View File

@ -80,6 +80,7 @@ unsigned int QObject_RegisterUserData();
void QObject_SetUserData(QObject* self, unsigned int id, QObjectUserData* data);
QObjectUserData* QObject_UserData(QObject* self, unsigned int id);
void QObject_Destroyed(QObject* self);
void QObject_connect_Destroyed(QObject* self, void* slot);
QObject* QObject_Parent(QObject* self);
bool QObject_Inherits(QObject* self, const char* classname);
void QObject_DeleteLater(QObject* self);

22
qt/gen_qobjectdefs.cpp
View File

@ -252,7 +252,7 @@ QObject* QMetaObject_NewInstance(QMetaObject* self) {
}
void QMetaObject_Tr3(QMetaObject* self, const char* s, const char* c, int n, char** _out, int* _out_Strlen) {
QString ret = self->tr(s, c, static_cast<int>(n));
QString ret = const_cast<const QMetaObject*>(self)->tr(s, c, static_cast<int>(n));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -433,43 +433,43 @@ bool QMetaObject_InvokeMethod124(QObject* obj, const char* member, QGenericArgum
}
QObject* QMetaObject_NewInstance1(QMetaObject* self, QGenericArgument* val0) {
return self->newInstance(*val0);
return const_cast<const QMetaObject*>(self)->newInstance(*val0);
}
QObject* QMetaObject_NewInstance2(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1) {
return self->newInstance(*val0, *val1);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1);
}
QObject* QMetaObject_NewInstance3(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2) {
return self->newInstance(*val0, *val1, *val2);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2);
}
QObject* QMetaObject_NewInstance4(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3) {
return self->newInstance(*val0, *val1, *val2, *val3);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3);
}
QObject* QMetaObject_NewInstance5(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4);
}
QObject* QMetaObject_NewInstance6(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4, *val5);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4, *val5);
}
QObject* QMetaObject_NewInstance7(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6);
}
QObject* QMetaObject_NewInstance8(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7);
}
QObject* QMetaObject_NewInstance9(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8);
}
QObject* QMetaObject_NewInstance10(QMetaObject* self, QGenericArgument* val0, QGenericArgument* val1, QGenericArgument* val2, QGenericArgument* val3, QGenericArgument* val4, QGenericArgument* val5, QGenericArgument* val6, QGenericArgument* val7, QGenericArgument* val8, QGenericArgument* val9) {
return self->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
return const_cast<const QMetaObject*>(self)->newInstance(*val0, *val1, *val2, *val3, *val4, *val5, *val6, *val7, *val8, *val9);
}
void QMetaObject_Delete(QMetaObject* self) {

40
qt/gen_qpixmap.cpp
View File

@ -151,7 +151,7 @@ QBitmap* QPixmap_CreateMaskFromColor(QPixmap* self, QColor* maskColor) {
}
QPixmap* QPixmap_GrabWindow(uintptr_t param1) {
QPixmap ret = QPixmap::grabWindow(static_cast<WId>(param1));
QPixmap ret = QPixmap::grabWindow(static_cast<quintptr>(param1));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
@ -309,37 +309,37 @@ void QPixmap_Fill1(QPixmap* self, QColor* fillColor) {
}
QBitmap* QPixmap_CreateHeuristicMask1(QPixmap* self, bool clipTight) {
QBitmap ret = self->createHeuristicMask(clipTight);
QBitmap ret = const_cast<const QPixmap*>(self)->createHeuristicMask(clipTight);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QBitmap*>(new QBitmap(ret));
}
QBitmap* QPixmap_CreateMaskFromColor2(QPixmap* self, QColor* maskColor, uintptr_t mode) {
QBitmap ret = self->createMaskFromColor(*maskColor, static_cast<Qt::MaskMode>(mode));
QBitmap ret = const_cast<const QPixmap*>(self)->createMaskFromColor(*maskColor, static_cast<Qt::MaskMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QBitmap*>(new QBitmap(ret));
}
QPixmap* QPixmap_GrabWindow2(uintptr_t param1, int x) {
QPixmap ret = QPixmap::grabWindow(static_cast<WId>(param1), static_cast<int>(x));
QPixmap ret = QPixmap::grabWindow(static_cast<quintptr>(param1), static_cast<int>(x));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_GrabWindow3(uintptr_t param1, int x, int y) {
QPixmap ret = QPixmap::grabWindow(static_cast<WId>(param1), static_cast<int>(x), static_cast<int>(y));
QPixmap ret = QPixmap::grabWindow(static_cast<quintptr>(param1), static_cast<int>(x), static_cast<int>(y));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_GrabWindow4(uintptr_t param1, int x, int y, int w) {
QPixmap ret = QPixmap::grabWindow(static_cast<WId>(param1), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w));
QPixmap ret = QPixmap::grabWindow(static_cast<quintptr>(param1), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_GrabWindow5(uintptr_t param1, int x, int y, int w, int h) {
QPixmap ret = QPixmap::grabWindow(static_cast<WId>(param1), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
QPixmap ret = QPixmap::grabWindow(static_cast<quintptr>(param1), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
@ -369,49 +369,49 @@ QPixmap* QPixmap_GrabWidget5(QObject* widget, int x, int y, int w, int h) {
}
QPixmap* QPixmap_Scaled3(QPixmap* self, int w, int h, uintptr_t aspectMode) {
QPixmap ret = self->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_Scaled4(QPixmap* self, int w, int h, uintptr_t aspectMode, uintptr_t mode) {
QPixmap ret = self->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaled(static_cast<int>(w), static_cast<int>(h), static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_Scaled2(QPixmap* self, QSize* s, uintptr_t aspectMode) {
QPixmap ret = self->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_Scaled32(QPixmap* self, QSize* s, uintptr_t aspectMode, uintptr_t mode) {
QPixmap ret = self->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaled(*s, static_cast<Qt::AspectRatioMode>(aspectMode), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_ScaledToWidth2(QPixmap* self, int w, uintptr_t mode) {
QPixmap ret = self->scaledToWidth(static_cast<int>(w), static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaledToWidth(static_cast<int>(w), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_ScaledToHeight2(QPixmap* self, int h, uintptr_t mode) {
QPixmap ret = self->scaledToHeight(static_cast<int>(h), static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->scaledToHeight(static_cast<int>(h), static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_Transformed2(QPixmap* self, QMatrix* param1, uintptr_t mode) {
QPixmap ret = self->transformed(*param1, static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->transformed(*param1, static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QPixmap_Transformed22(QPixmap* self, QTransform* param1, uintptr_t mode) {
QPixmap ret = self->transformed(*param1, static_cast<Qt::TransformationMode>(mode));
QPixmap ret = const_cast<const QPixmap*>(self)->transformed(*param1, static_cast<Qt::TransformationMode>(mode));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
@ -456,20 +456,20 @@ bool QPixmap_LoadFromData32(QPixmap* self, QByteArray* data, const char* format,
bool QPixmap_Save2(QPixmap* self, const char* fileName, size_t fileName_Strlen, const char* format) {
QString fileName_QString = QString::fromUtf8(fileName, fileName_Strlen);
return self->save(fileName_QString, format);
return const_cast<const QPixmap*>(self)->save(fileName_QString, format);
}
bool QPixmap_Save3(QPixmap* self, const char* fileName, size_t fileName_Strlen, const char* format, int quality) {
QString fileName_QString = QString::fromUtf8(fileName, fileName_Strlen);
return self->save(fileName_QString, format, static_cast<int>(quality));
return const_cast<const QPixmap*>(self)->save(fileName_QString, format, static_cast<int>(quality));
}
bool QPixmap_Save22(QPixmap* self, QIODevice* device, const char* format) {
return self->save(device, format);
return const_cast<const QPixmap*>(self)->save(device, format);
}
bool QPixmap_Save32(QPixmap* self, QIODevice* device, const char* format, int quality) {
return self->save(device, format, static_cast<int>(quality));
return const_cast<const QPixmap*>(self)->save(device, format, static_cast<int>(quality));
}
bool QPixmap_ConvertFromImage2(QPixmap* self, QImage* img, int flags) {
@ -477,7 +477,7 @@ bool QPixmap_ConvertFromImage2(QPixmap* self, QImage* img, int flags) {
}
QPixmap* QPixmap_Copy1(QPixmap* self, QRect* rect) {
QPixmap ret = self->copy(*rect);
QPixmap ret = const_cast<const QPixmap*>(self)->copy(*rect);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}

2
qt/gen_qprocess.cpp
View File

@ -120,7 +120,7 @@ QProcessEnvironment* QProcessEnvironment_SystemEnvironment() {
void QProcessEnvironment_Value2(QProcessEnvironment* self, const char* name, size_t name_Strlen, const char* defaultValue, size_t defaultValue_Strlen, char** _out, int* _out_Strlen) {
QString name_QString = QString::fromUtf8(name, name_Strlen);
QString defaultValue_QString = QString::fromUtf8(defaultValue, defaultValue_Strlen);
QString ret = self->value(name_QString, defaultValue_QString);
QString ret = const_cast<const QProcessEnvironment*>(self)->value(name_QString, defaultValue_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

30
qt/gen_qproxystyle.cpp
View File

@ -218,69 +218,69 @@ void QProxyStyle_TrUtf83(const char* s, const char* c, int n, char** _out, int*
}
void QProxyStyle_DrawPrimitive4(QProxyStyle* self, uintptr_t element, QStyleOption* option, QPainter* painter, QWidget* widget) {
self->drawPrimitive(static_cast<QStyle::PrimitiveElement>(element), option, painter, widget);
const_cast<const QProxyStyle*>(self)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(element), option, painter, widget);
}
void QProxyStyle_DrawControl4(QProxyStyle* self, uintptr_t element, QStyleOption* option, QPainter* painter, QWidget* widget) {
self->drawControl(static_cast<QStyle::ControlElement>(element), option, painter, widget);
const_cast<const QProxyStyle*>(self)->drawControl(static_cast<QStyle::ControlElement>(element), option, painter, widget);
}
void QProxyStyle_DrawComplexControl4(QProxyStyle* self, uintptr_t control, QStyleOptionComplex* option, QPainter* painter, QWidget* widget) {
self->drawComplexControl(static_cast<QStyle::ComplexControl>(control), option, painter, widget);
const_cast<const QProxyStyle*>(self)->drawComplexControl(static_cast<QStyle::ComplexControl>(control), option, painter, widget);
}
void QProxyStyle_DrawItemText7(QProxyStyle* self, QPainter* painter, QRect* rect, int flags, QPalette* pal, bool enabled, const char* text, size_t text_Strlen, uintptr_t textRole) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
self->drawItemText(painter, *rect, static_cast<int>(flags), *pal, enabled, text_QString, static_cast<QPalette::ColorRole>(textRole));
const_cast<const QProxyStyle*>(self)->drawItemText(painter, *rect, static_cast<int>(flags), *pal, enabled, text_QString, static_cast<QPalette::ColorRole>(textRole));
}
uintptr_t QProxyStyle_HitTestComplexControl4(QProxyStyle* self, uintptr_t control, QStyleOptionComplex* option, QPoint* pos, QWidget* widget) {
QStyle::SubControl ret = self->hitTestComplexControl(static_cast<QStyle::ComplexControl>(control), option, *pos, widget);
QStyle::SubControl ret = const_cast<const QProxyStyle*>(self)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(control), option, *pos, widget);
return static_cast<uintptr_t>(ret);
}
int QProxyStyle_StyleHint2(QProxyStyle* self, uintptr_t hint, QStyleOption* option) {
return self->styleHint(static_cast<QStyle::StyleHint>(hint), option);
return const_cast<const QProxyStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(hint), option);
}
int QProxyStyle_StyleHint3(QProxyStyle* self, uintptr_t hint, QStyleOption* option, QWidget* widget) {
return self->styleHint(static_cast<QStyle::StyleHint>(hint), option, widget);
return const_cast<const QProxyStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(hint), option, widget);
}
int QProxyStyle_StyleHint4(QProxyStyle* self, uintptr_t hint, QStyleOption* option, QWidget* widget, QStyleHintReturn* returnData) {
return self->styleHint(static_cast<QStyle::StyleHint>(hint), option, widget, returnData);
return const_cast<const QProxyStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(hint), option, widget, returnData);
}
int QProxyStyle_PixelMetric2(QProxyStyle* self, uintptr_t metric, QStyleOption* option) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option);
return const_cast<const QProxyStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option);
}
int QProxyStyle_PixelMetric3(QProxyStyle* self, uintptr_t metric, QStyleOption* option, QWidget* widget) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option, widget);
return const_cast<const QProxyStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option, widget);
}
int QProxyStyle_LayoutSpacing4(QProxyStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
return const_cast<const QProxyStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
}
int QProxyStyle_LayoutSpacing5(QProxyStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option, QWidget* widget) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
return const_cast<const QProxyStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
}
QIcon* QProxyStyle_StandardIcon2(QProxyStyle* self, uintptr_t standardIcon, QStyleOption* option) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option);
QIcon ret = const_cast<const QProxyStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
QIcon* QProxyStyle_StandardIcon3(QProxyStyle* self, uintptr_t standardIcon, QStyleOption* option, QWidget* widget) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option, widget);
QIcon ret = const_cast<const QProxyStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
QPixmap* QProxyStyle_StandardPixmap3(QProxyStyle* self, uintptr_t standardPixmap, QStyleOption* opt, QWidget* widget) {
QPixmap ret = self->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt, widget);
QPixmap ret = const_cast<const QProxyStyle*>(self)->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}

4
qt/gen_qrawfont.cpp
View File

@ -260,13 +260,13 @@ QRawFont* QRawFont_FromFont(QFont* font) {
}
QImage* QRawFont_AlphaMapForGlyph2(QRawFont* self, unsigned int glyphIndex, uintptr_t antialiasingType) {
QImage ret = self->alphaMapForGlyph(static_cast<quint32>(glyphIndex), static_cast<QRawFont::AntialiasingType>(antialiasingType));
QImage ret = const_cast<const QRawFont*>(self)->alphaMapForGlyph(static_cast<quint32>(glyphIndex), static_cast<QRawFont::AntialiasingType>(antialiasingType));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}
QImage* QRawFont_AlphaMapForGlyph3(QRawFont* self, unsigned int glyphIndex, uintptr_t antialiasingType, QTransform* transform) {
QImage ret = self->alphaMapForGlyph(static_cast<quint32>(glyphIndex), static_cast<QRawFont::AntialiasingType>(antialiasingType), *transform);
QImage ret = const_cast<const QRawFont*>(self)->alphaMapForGlyph(static_cast<quint32>(glyphIndex), static_cast<QRawFont::AntialiasingType>(antialiasingType), *transform);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QImage*>(new QImage(ret));
}

4
qt/gen_qrect.cpp
View File

@ -345,11 +345,11 @@ QRect* QRect_OperatorMinusAssign(QRect* self, QMargins* margins) {
}
bool QRect_Contains22(QRect* self, QRect* r, bool proper) {
return self->contains(*r, proper);
return const_cast<const QRect*>(self)->contains(*r, proper);
}
bool QRect_Contains23(QRect* self, QPoint* p, bool proper) {
return self->contains(*p, proper);
return const_cast<const QRect*>(self)->contains(*p, proper);
}
void QRect_Delete(QRect* self) {

12
qt/gen_qregexp.cpp
View File

@ -211,26 +211,26 @@ void QRegExp_Escape(const char* str, size_t str_Strlen, char** _out, int* _out_S
int QRegExp_IndexIn2(QRegExp* self, const char* str, size_t str_Strlen, int offset) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
return self->indexIn(str_QString, static_cast<int>(offset));
return const_cast<const QRegExp*>(self)->indexIn(str_QString, static_cast<int>(offset));
}
int QRegExp_IndexIn3(QRegExp* self, const char* str, size_t str_Strlen, int offset, uintptr_t caretMode) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
return self->indexIn(str_QString, static_cast<int>(offset), static_cast<QRegExp::CaretMode>(caretMode));
return const_cast<const QRegExp*>(self)->indexIn(str_QString, static_cast<int>(offset), static_cast<QRegExp::CaretMode>(caretMode));
}
int QRegExp_LastIndexIn2(QRegExp* self, const char* str, size_t str_Strlen, int offset) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
return self->lastIndexIn(str_QString, static_cast<int>(offset));
return const_cast<const QRegExp*>(self)->lastIndexIn(str_QString, static_cast<int>(offset));
}
int QRegExp_LastIndexIn3(QRegExp* self, const char* str, size_t str_Strlen, int offset, uintptr_t caretMode) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
return self->lastIndexIn(str_QString, static_cast<int>(offset), static_cast<QRegExp::CaretMode>(caretMode));
return const_cast<const QRegExp*>(self)->lastIndexIn(str_QString, static_cast<int>(offset), static_cast<QRegExp::CaretMode>(caretMode));
}
void QRegExp_Cap1(QRegExp* self, int nth, char** _out, int* _out_Strlen) {
QString ret = self->cap(static_cast<int>(nth));
QString ret = const_cast<const QRegExp*>(self)->cap(static_cast<int>(nth));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -248,7 +248,7 @@ void QRegExp_Cap1WithNth(QRegExp* self, int nth, char** _out, int* _out_Strlen)
}
int QRegExp_Pos1(QRegExp* self, int nth) {
return self->pos(static_cast<int>(nth));
return const_cast<const QRegExp*>(self)->pos(static_cast<int>(nth));
}
int QRegExp_Pos1WithNth(QRegExp* self, int nth) {

20
qt/gen_qregularexpression.cpp
View File

@ -158,42 +158,42 @@ bool QRegularExpression_OperatorNotEqual(QRegularExpression* self, QRegularExpre
QRegularExpressionMatch* QRegularExpression_Match2(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatch ret = self->match(subject_QString, static_cast<int>(offset));
QRegularExpressionMatch ret = const_cast<const QRegularExpression*>(self)->match(subject_QString, static_cast<int>(offset));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatch*>(new QRegularExpressionMatch(ret));
}
QRegularExpressionMatch* QRegularExpression_Match3(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset, uintptr_t matchType) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatch ret = self->match(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType));
QRegularExpressionMatch ret = const_cast<const QRegularExpression*>(self)->match(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatch*>(new QRegularExpressionMatch(ret));
}
QRegularExpressionMatch* QRegularExpression_Match4(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset, uintptr_t matchType, int matchOptions) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatch ret = self->match(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOptions>(matchOptions));
QRegularExpressionMatch ret = const_cast<const QRegularExpression*>(self)->match(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOptions>(matchOptions));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatch*>(new QRegularExpressionMatch(ret));
}
QRegularExpressionMatchIterator* QRegularExpression_GlobalMatch2(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatchIterator ret = self->globalMatch(subject_QString, static_cast<int>(offset));
QRegularExpressionMatchIterator ret = const_cast<const QRegularExpression*>(self)->globalMatch(subject_QString, static_cast<int>(offset));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatchIterator*>(new QRegularExpressionMatchIterator(ret));
}
QRegularExpressionMatchIterator* QRegularExpression_GlobalMatch3(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset, uintptr_t matchType) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatchIterator ret = self->globalMatch(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType));
QRegularExpressionMatchIterator ret = const_cast<const QRegularExpression*>(self)->globalMatch(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatchIterator*>(new QRegularExpressionMatchIterator(ret));
}
QRegularExpressionMatchIterator* QRegularExpression_GlobalMatch4(QRegularExpression* self, const char* subject, size_t subject_Strlen, int offset, uintptr_t matchType, int matchOptions) {
QString subject_QString = QString::fromUtf8(subject, subject_Strlen);
QRegularExpressionMatchIterator ret = self->globalMatch(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOptions>(matchOptions));
QRegularExpressionMatchIterator ret = const_cast<const QRegularExpression*>(self)->globalMatch(subject_QString, static_cast<int>(offset), static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOptions>(matchOptions));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRegularExpressionMatchIterator*>(new QRegularExpressionMatchIterator(ret));
}
@ -314,7 +314,7 @@ int QRegularExpressionMatch_CapturedEndWithName(QRegularExpressionMatch* self, c
}
void QRegularExpressionMatch_Captured1(QRegularExpressionMatch* self, int nth, char** _out, int* _out_Strlen) {
QString ret = self->captured(static_cast<int>(nth));
QString ret = const_cast<const QRegularExpressionMatch*>(self)->captured(static_cast<int>(nth));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -323,15 +323,15 @@ void QRegularExpressionMatch_Captured1(QRegularExpressionMatch* self, int nth, c
}
int QRegularExpressionMatch_CapturedStart1(QRegularExpressionMatch* self, int nth) {
return self->capturedStart(static_cast<int>(nth));
return const_cast<const QRegularExpressionMatch*>(self)->capturedStart(static_cast<int>(nth));
}
int QRegularExpressionMatch_CapturedLength1(QRegularExpressionMatch* self, int nth) {
return self->capturedLength(static_cast<int>(nth));
return const_cast<const QRegularExpressionMatch*>(self)->capturedLength(static_cast<int>(nth));
}
int QRegularExpressionMatch_CapturedEnd1(QRegularExpressionMatch* self, int nth) {
return self->capturedEnd(static_cast<int>(nth));
return const_cast<const QRegularExpressionMatch*>(self)->capturedEnd(static_cast<int>(nth));
}
void QRegularExpressionMatch_Delete(QRegularExpressionMatch* self) {

10
qt/gen_qscreen.cpp
View File

@ -226,7 +226,7 @@ bool QScreen_IsLandscape(QScreen* self, uintptr_t orientation) {
}
QPixmap* QScreen_GrabWindow(QScreen* self, uintptr_t window) {
QPixmap ret = self->grabWindow(static_cast<WId>(window));
QPixmap ret = self->grabWindow(static_cast<quintptr>(window));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
@ -362,25 +362,25 @@ void QScreen_TrUtf83(const char* s, const char* c, int n, char** _out, int* _out
}
QPixmap* QScreen_GrabWindow2(QScreen* self, uintptr_t window, int x) {
QPixmap ret = self->grabWindow(static_cast<WId>(window), static_cast<int>(x));
QPixmap ret = self->grabWindow(static_cast<quintptr>(window), static_cast<int>(x));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QScreen_GrabWindow3(QScreen* self, uintptr_t window, int x, int y) {
QPixmap ret = self->grabWindow(static_cast<WId>(window), static_cast<int>(x), static_cast<int>(y));
QPixmap ret = self->grabWindow(static_cast<quintptr>(window), static_cast<int>(x), static_cast<int>(y));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QScreen_GrabWindow4(QScreen* self, uintptr_t window, int x, int y, int w) {
QPixmap ret = self->grabWindow(static_cast<WId>(window), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w));
QPixmap ret = self->grabWindow(static_cast<quintptr>(window), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QScreen_GrabWindow5(QScreen* self, uintptr_t window, int x, int y, int w, int h) {
QPixmap ret = self->grabWindow(static_cast<WId>(window), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
QPixmap ret = self->grabWindow(static_cast<quintptr>(window), static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}

2
qt/gen_qsettings.cpp
View File

@ -372,7 +372,7 @@ void QSettings_BeginWriteArray2(QSettings* self, const char* prefix, size_t pref
QVariant* QSettings_Value2(QSettings* self, const char* key, size_t key_Strlen, QVariant* defaultValue) {
QString key_QString = QString::fromUtf8(key, key_Strlen);
QVariant ret = self->value(key_QString, *defaultValue);
QVariant ret = const_cast<const QSettings*>(self)->value(key_QString, *defaultValue);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}

8
qt/gen_qsocketnotifier.cpp
View File

@ -13,12 +13,12 @@ extern "C" {
extern void miqt_exec_callback(void* cb, int argc, void* argv);
}
QSocketNotifier* QSocketNotifier_new(ptrdiff_t socket, uintptr_t param2) {
return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2));
QSocketNotifier* QSocketNotifier_new(uintptr_t socket, uintptr_t param2) {
return new QSocketNotifier(static_cast<qptrdiff>(socket), static_cast<QSocketNotifier::Type>(param2));
}
QSocketNotifier* QSocketNotifier_new2(ptrdiff_t socket, uintptr_t param2, QObject* parent) {
return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2), parent);
QSocketNotifier* QSocketNotifier_new2(uintptr_t socket, uintptr_t param2, QObject* parent) {
return new QSocketNotifier(static_cast<qptrdiff>(socket), static_cast<QSocketNotifier::Type>(param2), parent);
}
QMetaObject* QSocketNotifier_MetaObject(QSocketNotifier* self) {

8
qt/gen_qsocketnotifier.go
View File

@ -45,14 +45,14 @@ func newQSocketNotifier_U(h unsafe.Pointer) *QSocketNotifier {
}
// NewQSocketNotifier constructs a new QSocketNotifier object.
func NewQSocketNotifier(socket uint64, param2 QSocketNotifier__Type) *QSocketNotifier {
ret := C.QSocketNotifier_new((C.ptrdiff_t)(socket), (C.uintptr_t)(param2))
func NewQSocketNotifier(socket uintptr, param2 QSocketNotifier__Type) *QSocketNotifier {
ret := C.QSocketNotifier_new((C.uintptr_t)(socket), (C.uintptr_t)(param2))
return newQSocketNotifier(ret)
}
// NewQSocketNotifier2 constructs a new QSocketNotifier object.
func NewQSocketNotifier2(socket uint64, param2 QSocketNotifier__Type, parent *QObject) *QSocketNotifier {
ret := C.QSocketNotifier_new2((C.ptrdiff_t)(socket), (C.uintptr_t)(param2), parent.cPointer())
func NewQSocketNotifier2(socket uintptr, param2 QSocketNotifier__Type, parent *QObject) *QSocketNotifier {
ret := C.QSocketNotifier_new2((C.uintptr_t)(socket), (C.uintptr_t)(param2), parent.cPointer())
return newQSocketNotifier(ret)
}

4
qt/gen_qsocketnotifier.h
View File

@ -23,8 +23,8 @@ typedef struct QSocketDescriptor QSocketDescriptor;
typedef struct QSocketNotifier QSocketNotifier;
#endif
QSocketNotifier* QSocketNotifier_new(ptrdiff_t socket, uintptr_t param2);
QSocketNotifier* QSocketNotifier_new2(ptrdiff_t socket, uintptr_t param2, QObject* parent);
QSocketNotifier* QSocketNotifier_new(uintptr_t socket, uintptr_t param2);
QSocketNotifier* QSocketNotifier_new2(uintptr_t socket, uintptr_t param2, QObject* parent);
QMetaObject* QSocketNotifier_MetaObject(QSocketNotifier* self);
void QSocketNotifier_Tr(const char* s, char** _out, int* _out_Strlen);
void QSocketNotifier_TrUtf8(const char* s, char** _out, int* _out_Strlen);

16
qt/gen_qsortfilterproxymodel.cpp
View File

@ -437,25 +437,25 @@ void QSortFilterProxyModel_TrUtf83(const char* s, const char* c, int n, char** _
}
QModelIndex* QSortFilterProxyModel_Index3(QSortFilterProxyModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QSortFilterProxyModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QSortFilterProxyModel_RowCount1(QSortFilterProxyModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QSortFilterProxyModel*>(self)->rowCount(*parent);
}
int QSortFilterProxyModel_ColumnCount1(QSortFilterProxyModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QSortFilterProxyModel*>(self)->columnCount(*parent);
}
bool QSortFilterProxyModel_HasChildren1(QSortFilterProxyModel* self, QModelIndex* parent) {
return self->hasChildren(*parent);
return const_cast<const QSortFilterProxyModel*>(self)->hasChildren(*parent);
}
QVariant* QSortFilterProxyModel_Data2(QSortFilterProxyModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QSortFilterProxyModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -465,7 +465,7 @@ bool QSortFilterProxyModel_SetData3(QSortFilterProxyModel* self, QModelIndex* in
}
QVariant* QSortFilterProxyModel_HeaderData3(QSortFilterProxyModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QSortFilterProxyModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -491,7 +491,7 @@ bool QSortFilterProxyModel_RemoveColumns3(QSortFilterProxyModel* self, int colum
}
void QSortFilterProxyModel_Match4(QSortFilterProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
QModelIndexList ret = const_cast<const QSortFilterProxyModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -502,7 +502,7 @@ void QSortFilterProxyModel_Match4(QSortFilterProxyModel* self, QModelIndex* star
}
void QSortFilterProxyModel_Match5(QSortFilterProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags, QModelIndex*** _out, size_t* _out_len) {
QModelIndexList ret = self->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
QModelIndexList ret = const_cast<const QSortFilterProxyModel*>(self)->match(*start, static_cast<int>(role), *value, static_cast<int>(hits), static_cast<Qt::MatchFlags>(flags));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QModelIndex** __out = static_cast<QModelIndex**>(malloc(sizeof(QModelIndex**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

22
qt/gen_qstandarditemmodel.cpp
View File

@ -482,7 +482,7 @@ bool QStandardItem_OperatorLesser(QStandardItem* self, QStandardItem* other) {
}
QVariant* QStandardItem_Data1(QStandardItem* self, int role) {
QVariant ret = self->data(static_cast<int>(role));
QVariant ret = const_cast<const QStandardItem*>(self)->data(static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -492,7 +492,7 @@ void QStandardItem_SetData2(QStandardItem* self, QVariant* value, int role) {
}
QStandardItem* QStandardItem_Child2(QStandardItem* self, int row, int column) {
return self->child(static_cast<int>(row), static_cast<int>(column));
return const_cast<const QStandardItem*>(self)->child(static_cast<int>(row), static_cast<int>(column));
}
QStandardItem* QStandardItem_TakeChild2(QStandardItem* self, int row, int column) {
@ -892,25 +892,25 @@ void QStandardItemModel_TrUtf83(const char* s, const char* c, int n, char** _out
}
QModelIndex* QStandardItemModel_Index3(QStandardItemModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QStandardItemModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}
int QStandardItemModel_RowCount1(QStandardItemModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QStandardItemModel*>(self)->rowCount(*parent);
}
int QStandardItemModel_ColumnCount1(QStandardItemModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QStandardItemModel*>(self)->columnCount(*parent);
}
bool QStandardItemModel_HasChildren1(QStandardItemModel* self, QModelIndex* parent) {
return self->hasChildren(*parent);
return const_cast<const QStandardItemModel*>(self)->hasChildren(*parent);
}
QVariant* QStandardItemModel_Data2(QStandardItemModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QStandardItemModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -920,7 +920,7 @@ bool QStandardItemModel_SetData3(QStandardItemModel* self, QModelIndex* index, Q
}
QVariant* QStandardItemModel_HeaderData3(QStandardItemModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QStandardItemModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -950,7 +950,7 @@ void QStandardItemModel_Sort2(QStandardItemModel* self, int column, uintptr_t or
}
QStandardItem* QStandardItemModel_Item2(QStandardItemModel* self, int row, int column) {
return self->item(static_cast<int>(row), static_cast<int>(column));
return const_cast<const QStandardItemModel*>(self)->item(static_cast<int>(row), static_cast<int>(column));
}
bool QStandardItemModel_InsertRow22(QStandardItemModel* self, int row, QModelIndex* parent) {
@ -967,7 +967,7 @@ QStandardItem* QStandardItemModel_TakeItem2(QStandardItemModel* self, int row, i
void QStandardItemModel_FindItems2(QStandardItemModel* self, const char* text, size_t text_Strlen, int flags, QStandardItem*** _out, size_t* _out_len) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QList<QStandardItem*> ret = self->findItems(text_QString, static_cast<Qt::MatchFlags>(flags));
QList<QStandardItem*> ret = const_cast<const QStandardItemModel*>(self)->findItems(text_QString, static_cast<Qt::MatchFlags>(flags));
// Convert QList<> from C++ memory to manually-managed C memory
QStandardItem** __out = static_cast<QStandardItem**>(malloc(sizeof(QStandardItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -979,7 +979,7 @@ void QStandardItemModel_FindItems2(QStandardItemModel* self, const char* text, s
void QStandardItemModel_FindItems3(QStandardItemModel* self, const char* text, size_t text_Strlen, int flags, int column, QStandardItem*** _out, size_t* _out_len) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QList<QStandardItem*> ret = self->findItems(text_QString, static_cast<Qt::MatchFlags>(flags), static_cast<int>(column));
QList<QStandardItem*> ret = const_cast<const QStandardItemModel*>(self)->findItems(text_QString, static_cast<Qt::MatchFlags>(flags), static_cast<int>(column));
// Convert QList<> from C++ memory to manually-managed C memory
QStandardItem** __out = static_cast<QStandardItem**>(malloc(sizeof(QStandardItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

4
qt/gen_qstringlistmodel.cpp
View File

@ -172,11 +172,11 @@ void QStringListModel_TrUtf83(const char* s, const char* c, int n, char** _out,
}
int QStringListModel_RowCount1(QStringListModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QStringListModel*>(self)->rowCount(*parent);
}
QVariant* QStringListModel_Data2(QStringListModel* self, QModelIndex* index, int role) {
QVariant ret = self->data(*index, static_cast<int>(role));
QVariant ret = const_cast<const QStringListModel*>(self)->data(*index, static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}

4
qt/gen_qstringmatcher.cpp
View File

@ -75,11 +75,11 @@ uintptr_t QStringMatcher_CaseSensitivity(QStringMatcher* self) {
int QStringMatcher_IndexIn22(QStringMatcher* self, const char* str, size_t str_Strlen, int from) {
QString str_QString = QString::fromUtf8(str, str_Strlen);
return self->indexIn(str_QString, static_cast<int>(from));
return const_cast<const QStringMatcher*>(self)->indexIn(str_QString, static_cast<int>(from));
}
int QStringMatcher_IndexIn3(QStringMatcher* self, QChar* str, int length, int from) {
return self->indexIn(str, static_cast<int>(length), static_cast<int>(from));
return const_cast<const QStringMatcher*>(self)->indexIn(str, static_cast<int>(length), static_cast<int>(from));
}
void QStringMatcher_Delete(QStringMatcher* self) {

48
qt/gen_qstringview.cpp
View File

@ -208,99 +208,99 @@ QChar* QStringView_Last(QStringView* self) {
}
size_t QStringView_IndexOf2(QStringView* self, QChar* c, size_t from) {
return self->indexOf(*c, static_cast<qsizetype>(from));
return const_cast<const QStringView*>(self)->indexOf(*c, static_cast<qsizetype>(from));
}
size_t QStringView_IndexOf3(QStringView* self, QChar* c, size_t from, uintptr_t cs) {
return self->indexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QStringView*>(self)->indexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
}
bool QStringView_Contains2(QStringView* self, QChar* c, uintptr_t cs) {
return self->contains(*c, static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QStringView*>(self)->contains(*c, static_cast<Qt::CaseSensitivity>(cs));
}
size_t QStringView_Count2(QStringView* self, QChar* c, uintptr_t cs) {
return self->count(*c, static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QStringView*>(self)->count(*c, static_cast<Qt::CaseSensitivity>(cs));
}
size_t QStringView_LastIndexOf2(QStringView* self, QChar* c, size_t from) {
return self->lastIndexOf(*c, static_cast<qsizetype>(from));
return const_cast<const QStringView*>(self)->lastIndexOf(*c, static_cast<qsizetype>(from));
}
size_t QStringView_LastIndexOf3(QStringView* self, QChar* c, size_t from, uintptr_t cs) {
return self->lastIndexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
return const_cast<const QStringView*>(self)->lastIndexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
}
int16_t QStringView_ToShort1(QStringView* self, bool* ok) {
return self->toShort(ok);
return const_cast<const QStringView*>(self)->toShort(ok);
}
int16_t QStringView_ToShort2(QStringView* self, bool* ok, int base) {
return self->toShort(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toShort(ok, static_cast<int>(base));
}
uint16_t QStringView_ToUShort1(QStringView* self, bool* ok) {
return self->toUShort(ok);
return const_cast<const QStringView*>(self)->toUShort(ok);
}
uint16_t QStringView_ToUShort2(QStringView* self, bool* ok, int base) {
return self->toUShort(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toUShort(ok, static_cast<int>(base));
}
int QStringView_ToInt1(QStringView* self, bool* ok) {
return self->toInt(ok);
return const_cast<const QStringView*>(self)->toInt(ok);
}
int QStringView_ToInt2(QStringView* self, bool* ok, int base) {
return self->toInt(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toInt(ok, static_cast<int>(base));
}
unsigned int QStringView_ToUInt1(QStringView* self, bool* ok) {
return self->toUInt(ok);
return const_cast<const QStringView*>(self)->toUInt(ok);
}
unsigned int QStringView_ToUInt2(QStringView* self, bool* ok, int base) {
return self->toUInt(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toUInt(ok, static_cast<int>(base));
}
long QStringView_ToLong1(QStringView* self, bool* ok) {
return self->toLong(ok);
return const_cast<const QStringView*>(self)->toLong(ok);
}
long QStringView_ToLong2(QStringView* self, bool* ok, int base) {
return self->toLong(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toLong(ok, static_cast<int>(base));
}
unsigned long QStringView_ToULong1(QStringView* self, bool* ok) {
return self->toULong(ok);
return const_cast<const QStringView*>(self)->toULong(ok);
}
unsigned long QStringView_ToULong2(QStringView* self, bool* ok, int base) {
return self->toULong(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toULong(ok, static_cast<int>(base));
}
int64_t QStringView_ToLongLong1(QStringView* self, bool* ok) {
return self->toLongLong(ok);
return const_cast<const QStringView*>(self)->toLongLong(ok);
}
int64_t QStringView_ToLongLong2(QStringView* self, bool* ok, int base) {
return self->toLongLong(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toLongLong(ok, static_cast<int>(base));
}
uint64_t QStringView_ToULongLong1(QStringView* self, bool* ok) {
return self->toULongLong(ok);
return const_cast<const QStringView*>(self)->toULongLong(ok);
}
uint64_t QStringView_ToULongLong2(QStringView* self, bool* ok, int base) {
return self->toULongLong(ok, static_cast<int>(base));
return const_cast<const QStringView*>(self)->toULongLong(ok, static_cast<int>(base));
}
float QStringView_ToFloat1(QStringView* self, bool* ok) {
return self->toFloat(ok);
return const_cast<const QStringView*>(self)->toFloat(ok);
}
double QStringView_ToDouble1(QStringView* self, bool* ok) {
return self->toDouble(ok);
return const_cast<const QStringView*>(self)->toDouble(ok);
}
void QStringView_Delete(QStringView* self) {

42
qt/gen_qstyle.cpp
View File

@ -236,84 +236,84 @@ void QStyle_TrUtf83(const char* s, const char* c, int n, char** _out, int* _out_
void QStyle_DrawItemText7(QStyle* self, QPainter* painter, QRect* rect, int flags, QPalette* pal, bool enabled, const char* text, size_t text_Strlen, uintptr_t textRole) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
self->drawItemText(painter, *rect, static_cast<int>(flags), *pal, enabled, text_QString, static_cast<QPalette::ColorRole>(textRole));
const_cast<const QStyle*>(self)->drawItemText(painter, *rect, static_cast<int>(flags), *pal, enabled, text_QString, static_cast<QPalette::ColorRole>(textRole));
}
void QStyle_DrawPrimitive4(QStyle* self, uintptr_t pe, QStyleOption* opt, QPainter* p, QWidget* w) {
self->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), opt, p, w);
const_cast<const QStyle*>(self)->drawPrimitive(static_cast<QStyle::PrimitiveElement>(pe), opt, p, w);
}
void QStyle_DrawControl4(QStyle* self, uintptr_t element, QStyleOption* opt, QPainter* p, QWidget* w) {
self->drawControl(static_cast<QStyle::ControlElement>(element), opt, p, w);
const_cast<const QStyle*>(self)->drawControl(static_cast<QStyle::ControlElement>(element), opt, p, w);
}
QRect* QStyle_SubElementRect3(QStyle* self, uintptr_t subElement, QStyleOption* option, QWidget* widget) {
QRect ret = self->subElementRect(static_cast<QStyle::SubElement>(subElement), option, widget);
QRect ret = const_cast<const QStyle*>(self)->subElementRect(static_cast<QStyle::SubElement>(subElement), option, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
void QStyle_DrawComplexControl4(QStyle* self, uintptr_t cc, QStyleOptionComplex* opt, QPainter* p, QWidget* widget) {
self->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, p, widget);
const_cast<const QStyle*>(self)->drawComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, p, widget);
}
uintptr_t QStyle_HitTestComplexControl4(QStyle* self, uintptr_t cc, QStyleOptionComplex* opt, QPoint* pt, QWidget* widget) {
QStyle::SubControl ret = self->hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, *pt, widget);
QStyle::SubControl ret = const_cast<const QStyle*>(self)->hitTestComplexControl(static_cast<QStyle::ComplexControl>(cc), opt, *pt, widget);
return static_cast<uintptr_t>(ret);
}
QRect* QStyle_SubControlRect4(QStyle* self, uintptr_t cc, QStyleOptionComplex* opt, uintptr_t sc, QWidget* widget) {
QRect ret = self->subControlRect(static_cast<QStyle::ComplexControl>(cc), opt, static_cast<QStyle::SubControl>(sc), widget);
QRect ret = const_cast<const QStyle*>(self)->subControlRect(static_cast<QStyle::ComplexControl>(cc), opt, static_cast<QStyle::SubControl>(sc), widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QRect*>(new QRect(ret));
}
int QStyle_PixelMetric2(QStyle* self, uintptr_t metric, QStyleOption* option) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option);
return const_cast<const QStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option);
}
int QStyle_PixelMetric3(QStyle* self, uintptr_t metric, QStyleOption* option, QWidget* widget) {
return self->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option, widget);
return const_cast<const QStyle*>(self)->pixelMetric(static_cast<QStyle::PixelMetric>(metric), option, widget);
}
QSize* QStyle_SizeFromContents4(QStyle* self, uintptr_t ct, QStyleOption* opt, QSize* contentsSize, QWidget* w) {
QSize ret = self->sizeFromContents(static_cast<QStyle::ContentsType>(ct), opt, *contentsSize, w);
QSize ret = const_cast<const QStyle*>(self)->sizeFromContents(static_cast<QStyle::ContentsType>(ct), opt, *contentsSize, w);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QSize*>(new QSize(ret));
}
int QStyle_StyleHint2(QStyle* self, uintptr_t stylehint, QStyleOption* opt) {
return self->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt);
return const_cast<const QStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt);
}
int QStyle_StyleHint3(QStyle* self, uintptr_t stylehint, QStyleOption* opt, QWidget* widget) {
return self->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt, widget);
return const_cast<const QStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt, widget);
}
int QStyle_StyleHint4(QStyle* self, uintptr_t stylehint, QStyleOption* opt, QWidget* widget, QStyleHintReturn* returnData) {
return self->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt, widget, returnData);
return const_cast<const QStyle*>(self)->styleHint(static_cast<QStyle::StyleHint>(stylehint), opt, widget, returnData);
}
QPixmap* QStyle_StandardPixmap2(QStyle* self, uintptr_t standardPixmap, QStyleOption* opt) {
QPixmap ret = self->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt);
QPixmap ret = const_cast<const QStyle*>(self)->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QPixmap* QStyle_StandardPixmap3(QStyle* self, uintptr_t standardPixmap, QStyleOption* opt, QWidget* widget) {
QPixmap ret = self->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt, widget);
QPixmap ret = const_cast<const QStyle*>(self)->standardPixmap(static_cast<QStyle::StandardPixmap>(standardPixmap), opt, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QPixmap*>(new QPixmap(ret));
}
QIcon* QStyle_StandardIcon2(QStyle* self, uintptr_t standardIcon, QStyleOption* option) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option);
QIcon ret = const_cast<const QStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
QIcon* QStyle_StandardIcon3(QStyle* self, uintptr_t standardIcon, QStyleOption* option, QWidget* widget) {
QIcon ret = self->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option, widget);
QIcon ret = const_cast<const QStyle*>(self)->standardIcon(static_cast<QStyle::StandardPixmap>(standardIcon), option, widget);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QIcon*>(new QIcon(ret));
}
@ -327,19 +327,19 @@ int QStyle_SliderValueFromPosition5(int min, int max, int pos, int space, bool u
}
int QStyle_LayoutSpacing4(QStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
return const_cast<const QStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option);
}
int QStyle_LayoutSpacing5(QStyle* self, uintptr_t control1, uintptr_t control2, uintptr_t orientation, QStyleOption* option, QWidget* widget) {
return self->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
return const_cast<const QStyle*>(self)->layoutSpacing(static_cast<QSizePolicy::ControlType>(control1), static_cast<QSizePolicy::ControlType>(control2), static_cast<Qt::Orientation>(orientation), option, widget);
}
int QStyle_CombinedLayoutSpacing4(QStyle* self, int controls1, int controls2, uintptr_t orientation, QStyleOption* option) {
return self->combinedLayoutSpacing(static_cast<QSizePolicy::ControlTypes>(controls1), static_cast<QSizePolicy::ControlTypes>(controls2), static_cast<Qt::Orientation>(orientation), option);
return const_cast<const QStyle*>(self)->combinedLayoutSpacing(static_cast<QSizePolicy::ControlTypes>(controls1), static_cast<QSizePolicy::ControlTypes>(controls2), static_cast<Qt::Orientation>(orientation), option);
}
int QStyle_CombinedLayoutSpacing5(QStyle* self, int controls1, int controls2, uintptr_t orientation, QStyleOption* option, QWidget* widget) {
return self->combinedLayoutSpacing(static_cast<QSizePolicy::ControlTypes>(controls1), static_cast<QSizePolicy::ControlTypes>(controls2), static_cast<Qt::Orientation>(orientation), option, widget);
return const_cast<const QStyle*>(self)->combinedLayoutSpacing(static_cast<QSizePolicy::ControlTypes>(controls1), static_cast<QSizePolicy::ControlTypes>(controls2), static_cast<Qt::Orientation>(orientation), option, widget);
}
void QStyle_Delete(QStyle* self) {

2
qt/gen_qtabwidget.cpp
View File

@ -359,7 +359,7 @@ void QTabWidget_SetCornerWidget2(QTabWidget* self, QWidget* w, uintptr_t corner)
}
QWidget* QTabWidget_CornerWidget1(QTabWidget* self, uintptr_t corner) {
return self->cornerWidget(static_cast<Qt::Corner>(corner));
return const_cast<const QTabWidget*>(self)->cornerWidget(static_cast<Qt::Corner>(corner));
}
void QTabWidget_Delete(QTabWidget* self) {

8
qt/gen_qtextcodec.cpp
View File

@ -153,7 +153,7 @@ int QTextCodec_MibEnum(QTextCodec* self) {
}
void QTextCodec_ToUnicode3(QTextCodec* self, const char* in, int length, QTextCodec__ConverterState* state, char** _out, int* _out_Strlen) {
QString ret = self->toUnicode(in, static_cast<int>(length), state);
QString ret = const_cast<const QTextCodec*>(self)->toUnicode(in, static_cast<int>(length), state);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -162,17 +162,17 @@ void QTextCodec_ToUnicode3(QTextCodec* self, const char* in, int length, QTextCo
}
QByteArray* QTextCodec_FromUnicode3(QTextCodec* self, QChar* in, int length, QTextCodec__ConverterState* state) {
QByteArray ret = self->fromUnicode(in, static_cast<int>(length), state);
QByteArray ret = const_cast<const QTextCodec*>(self)->fromUnicode(in, static_cast<int>(length), state);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QByteArray*>(new QByteArray(ret));
}
QTextDecoder* QTextCodec_MakeDecoder1(QTextCodec* self, int flags) {
return self->makeDecoder(static_cast<QTextCodec::ConversionFlags>(flags));
return const_cast<const QTextCodec*>(self)->makeDecoder(static_cast<QTextCodec::ConversionFlags>(flags));
}
QTextEncoder* QTextCodec_MakeEncoder1(QTextCodec* self, int flags) {
return self->makeEncoder(static_cast<QTextCodec::ConversionFlags>(flags));
return const_cast<const QTextCodec*>(self)->makeEncoder(static_cast<QTextCodec::ConversionFlags>(flags));
}
QTextEncoder* QTextEncoder_new(QTextCodec* codec) {

24
qt/gen_qtextdocument.cpp
View File

@ -630,11 +630,11 @@ void QTextDocument_TrUtf83(const char* s, const char* c, int n, char** _out, int
}
QTextDocument* QTextDocument_Clone1(QTextDocument* self, QObject* parent) {
return self->clone(parent);
return const_cast<const QTextDocument*>(self)->clone(parent);
}
void QTextDocument_ToHtml1(QTextDocument* self, QByteArray* encoding, char** _out, int* _out_Strlen) {
QString ret = self->toHtml(*encoding);
QString ret = const_cast<const QTextDocument*>(self)->toHtml(*encoding);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -643,7 +643,7 @@ void QTextDocument_ToHtml1(QTextDocument* self, QByteArray* encoding, char** _ou
}
void QTextDocument_ToMarkdown1(QTextDocument* self, int features, char** _out, int* _out_Strlen) {
QString ret = self->toMarkdown(static_cast<QTextDocument::MarkdownFeatures>(features));
QString ret = const_cast<const QTextDocument*>(self)->toMarkdown(static_cast<QTextDocument::MarkdownFeatures>(features));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -658,57 +658,57 @@ void QTextDocument_SetMarkdown2(QTextDocument* self, const char* markdown, size_
QTextCursor* QTextDocument_Find22(QTextDocument* self, const char* subString, size_t subString_Strlen, int from) {
QString subString_QString = QString::fromUtf8(subString, subString_Strlen);
QTextCursor ret = self->find(subString_QString, static_cast<int>(from));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(subString_QString, static_cast<int>(from));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find32(QTextDocument* self, const char* subString, size_t subString_Strlen, int from, int options) {
QString subString_QString = QString::fromUtf8(subString, subString_Strlen);
QTextCursor ret = self->find(subString_QString, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(subString_QString, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find33(QTextDocument* self, const char* subString, size_t subString_Strlen, QTextCursor* cursor, int options) {
QString subString_QString = QString::fromUtf8(subString, subString_Strlen);
QTextCursor ret = self->find(subString_QString, *cursor, static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(subString_QString, *cursor, static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find23(QTextDocument* self, QRegExp* expr, int from) {
QTextCursor ret = self->find(*expr, static_cast<int>(from));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, static_cast<int>(from));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find34(QTextDocument* self, QRegExp* expr, int from, int options) {
QTextCursor ret = self->find(*expr, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find35(QTextDocument* self, QRegExp* expr, QTextCursor* cursor, int options) {
QTextCursor ret = self->find(*expr, *cursor, static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, *cursor, static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find24(QTextDocument* self, QRegularExpression* expr, int from) {
QTextCursor ret = self->find(*expr, static_cast<int>(from));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, static_cast<int>(from));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find36(QTextDocument* self, QRegularExpression* expr, int from, int options) {
QTextCursor ret = self->find(*expr, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, static_cast<int>(from), static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}
QTextCursor* QTextDocument_Find37(QTextDocument* self, QRegularExpression* expr, QTextCursor* cursor, int options) {
QTextCursor ret = self->find(*expr, *cursor, static_cast<QTextDocument::FindFlags>(options));
QTextCursor ret = const_cast<const QTextDocument*>(self)->find(*expr, *cursor, static_cast<QTextDocument::FindFlags>(options));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTextCursor*>(new QTextCursor(ret));
}

2
qt/gen_qtextdocumentfragment.cpp
View File

@ -77,7 +77,7 @@ QTextDocumentFragment* QTextDocumentFragment_FromHtml2(const char* html, size_t
}
void QTextDocumentFragment_ToHtml1(QTextDocumentFragment* self, QByteArray* encoding, char** _out, int* _out_Strlen) {
QString ret = self->toHtml(*encoding);
QString ret = const_cast<const QTextDocumentFragment*>(self)->toHtml(*encoding);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

2
qt/gen_qtextedit.cpp
View File

@ -645,7 +645,7 @@ bool QTextEdit_Find24(QTextEdit* self, QRegularExpression* exp, int options) {
}
void QTextEdit_ToMarkdown1(QTextEdit* self, int features, char** _out, int* _out_Strlen) {
QString ret = self->toMarkdown(static_cast<QTextDocument::MarkdownFeatures>(features));
QString ret = const_cast<const QTextEdit*>(self)->toMarkdown(static_cast<QTextDocument::MarkdownFeatures>(features));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

24
qt/gen_qtextlayout.cpp
View File

@ -339,11 +339,11 @@ void QTextLayout_SetFlags(QTextLayout* self, int flags) {
}
int QTextLayout_NextCursorPosition2(QTextLayout* self, int oldPos, uintptr_t mode) {
return self->nextCursorPosition(static_cast<int>(oldPos), static_cast<QTextLayout::CursorMode>(mode));
return const_cast<const QTextLayout*>(self)->nextCursorPosition(static_cast<int>(oldPos), static_cast<QTextLayout::CursorMode>(mode));
}
int QTextLayout_PreviousCursorPosition2(QTextLayout* self, int oldPos, uintptr_t mode) {
return self->previousCursorPosition(static_cast<int>(oldPos), static_cast<QTextLayout::CursorMode>(mode));
return const_cast<const QTextLayout*>(self)->previousCursorPosition(static_cast<int>(oldPos), static_cast<QTextLayout::CursorMode>(mode));
}
void QTextLayout_Draw3(QTextLayout* self, QPainter* p, QPointF* pos, QTextLayout__FormatRange** selections, size_t selections_len) {
@ -352,7 +352,7 @@ void QTextLayout_Draw3(QTextLayout* self, QPainter* p, QPointF* pos, QTextLayout
for(size_t i = 0; i < selections_len; ++i) {
selections_QList.push_back(*(selections[i]));
}
self->draw(p, *pos, selections_QList);
const_cast<const QTextLayout*>(self)->draw(p, *pos, selections_QList);
}
void QTextLayout_Draw4(QTextLayout* self, QPainter* p, QPointF* pos, QTextLayout__FormatRange** selections, size_t selections_len, QRectF* clip) {
@ -361,11 +361,11 @@ void QTextLayout_Draw4(QTextLayout* self, QPainter* p, QPointF* pos, QTextLayout
for(size_t i = 0; i < selections_len; ++i) {
selections_QList.push_back(*(selections[i]));
}
self->draw(p, *pos, selections_QList, *clip);
const_cast<const QTextLayout*>(self)->draw(p, *pos, selections_QList, *clip);
}
void QTextLayout_GlyphRuns1(QTextLayout* self, int from, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from));
QList<QGlyphRun> ret = const_cast<const QTextLayout*>(self)->glyphRuns(static_cast<int>(from));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -376,7 +376,7 @@ void QTextLayout_GlyphRuns1(QTextLayout* self, int from, QGlyphRun*** _out, size
}
void QTextLayout_GlyphRuns2(QTextLayout* self, int from, int length, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from), static_cast<int>(length));
QList<QGlyphRun> ret = const_cast<const QTextLayout*>(self)->glyphRuns(static_cast<int>(from), static_cast<int>(length));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -516,23 +516,23 @@ void QTextLine_GlyphRuns(QTextLine* self, QGlyphRun*** _out, size_t* _out_len) {
}
double QTextLine_CursorToX2(QTextLine* self, int* cursorPos, uintptr_t edge) {
return self->cursorToX(static_cast<int*>(cursorPos), static_cast<QTextLine::Edge>(edge));
return const_cast<const QTextLine*>(self)->cursorToX(static_cast<int*>(cursorPos), static_cast<QTextLine::Edge>(edge));
}
double QTextLine_CursorToX22(QTextLine* self, int cursorPos, uintptr_t edge) {
return self->cursorToX(static_cast<int>(cursorPos), static_cast<QTextLine::Edge>(edge));
return const_cast<const QTextLine*>(self)->cursorToX(static_cast<int>(cursorPos), static_cast<QTextLine::Edge>(edge));
}
int QTextLine_XToCursor2(QTextLine* self, double x, uintptr_t param2) {
return self->xToCursor(static_cast<qreal>(x), static_cast<QTextLine::CursorPosition>(param2));
return const_cast<const QTextLine*>(self)->xToCursor(static_cast<qreal>(x), static_cast<QTextLine::CursorPosition>(param2));
}
void QTextLine_Draw3(QTextLine* self, QPainter* p, QPointF* point, QTextLayout__FormatRange* selection) {
self->draw(p, *point, selection);
const_cast<const QTextLine*>(self)->draw(p, *point, selection);
}
void QTextLine_GlyphRuns1(QTextLine* self, int from, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from));
QList<QGlyphRun> ret = const_cast<const QTextLine*>(self)->glyphRuns(static_cast<int>(from));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -543,7 +543,7 @@ void QTextLine_GlyphRuns1(QTextLine* self, int from, QGlyphRun*** _out, size_t*
}
void QTextLine_GlyphRuns2(QTextLine* self, int from, int length, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from), static_cast<int>(length));
QList<QGlyphRun> ret = const_cast<const QTextLine*>(self)->glyphRuns(static_cast<int>(from), static_cast<int>(length));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

4
qt/gen_qtextobject.cpp
View File

@ -563,7 +563,7 @@ void QTextFragment_GlyphRuns(QTextFragment* self, QGlyphRun*** _out, size_t* _ou
}
void QTextFragment_GlyphRuns1(QTextFragment* self, int from, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from));
QList<QGlyphRun> ret = const_cast<const QTextFragment*>(self)->glyphRuns(static_cast<int>(from));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {
@ -574,7 +574,7 @@ void QTextFragment_GlyphRuns1(QTextFragment* self, int from, QGlyphRun*** _out,
}
void QTextFragment_GlyphRuns2(QTextFragment* self, int from, int length, QGlyphRun*** _out, size_t* _out_len) {
QList<QGlyphRun> ret = self->glyphRuns(static_cast<int>(from), static_cast<int>(length));
QList<QGlyphRun> ret = const_cast<const QTextFragment*>(self)->glyphRuns(static_cast<int>(from), static_cast<int>(length));
// Convert QList<> from C++ memory to manually-managed C memory of copy-constructed pointers
QGlyphRun** __out = static_cast<QGlyphRun**>(malloc(sizeof(QGlyphRun**) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

8
qt/gen_qtimezone.cpp
View File

@ -266,7 +266,7 @@ void QTimeZone_WindowsIdToIanaIds2(QByteArray* windowsId, uintptr_t country, QBy
}
void QTimeZone_DisplayName2(QTimeZone* self, QDateTime* atDateTime, uintptr_t nameType, char** _out, int* _out_Strlen) {
QString ret = self->displayName(*atDateTime, static_cast<QTimeZone::NameType>(nameType));
QString ret = const_cast<const QTimeZone*>(self)->displayName(*atDateTime, static_cast<QTimeZone::NameType>(nameType));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -275,7 +275,7 @@ void QTimeZone_DisplayName2(QTimeZone* self, QDateTime* atDateTime, uintptr_t na
}
void QTimeZone_DisplayName3(QTimeZone* self, QDateTime* atDateTime, uintptr_t nameType, QLocale* locale, char** _out, int* _out_Strlen) {
QString ret = self->displayName(*atDateTime, static_cast<QTimeZone::NameType>(nameType), *locale);
QString ret = const_cast<const QTimeZone*>(self)->displayName(*atDateTime, static_cast<QTimeZone::NameType>(nameType), *locale);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -284,7 +284,7 @@ void QTimeZone_DisplayName3(QTimeZone* self, QDateTime* atDateTime, uintptr_t na
}
void QTimeZone_DisplayName22(QTimeZone* self, uintptr_t timeType, uintptr_t nameType, char** _out, int* _out_Strlen) {
QString ret = self->displayName(static_cast<QTimeZone::TimeType>(timeType), static_cast<QTimeZone::NameType>(nameType));
QString ret = const_cast<const QTimeZone*>(self)->displayName(static_cast<QTimeZone::TimeType>(timeType), static_cast<QTimeZone::NameType>(nameType));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -293,7 +293,7 @@ void QTimeZone_DisplayName22(QTimeZone* self, uintptr_t timeType, uintptr_t name
}
void QTimeZone_DisplayName32(QTimeZone* self, uintptr_t timeType, uintptr_t nameType, QLocale* locale, char** _out, int* _out_Strlen) {
QString ret = self->displayName(static_cast<QTimeZone::TimeType>(timeType), static_cast<QTimeZone::NameType>(nameType), *locale);
QString ret = const_cast<const QTimeZone*>(self)->displayName(static_cast<QTimeZone::TimeType>(timeType), static_cast<QTimeZone::NameType>(nameType), *locale);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

2
qt/gen_qtransform.cpp
View File

@ -304,7 +304,7 @@ QTransform* QTransform_FromScale(double dx, double dy) {
}
QTransform* QTransform_Inverted1(QTransform* self, bool* invertible) {
QTransform ret = self->inverted(invertible);
QTransform ret = const_cast<const QTransform*>(self)->inverted(invertible);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QTransform*>(new QTransform(ret));
}

4
qt/gen_qtranslator.cpp
View File

@ -125,7 +125,7 @@ void QTranslator_TrUtf83(const char* s, const char* c, int n, char** _out, int*
}
void QTranslator_Translate3(QTranslator* self, const char* context, const char* sourceText, const char* disambiguation, char** _out, int* _out_Strlen) {
QString ret = self->translate(context, sourceText, disambiguation);
QString ret = const_cast<const QTranslator*>(self)->translate(context, sourceText, disambiguation);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -134,7 +134,7 @@ void QTranslator_Translate3(QTranslator* self, const char* context, const char*
}
void QTranslator_Translate4(QTranslator* self, const char* context, const char* sourceText, const char* disambiguation, int n, char** _out, int* _out_Strlen) {
QString ret = self->translate(context, sourceText, disambiguation, static_cast<int>(n));
QString ret = const_cast<const QTranslator*>(self)->translate(context, sourceText, disambiguation, static_cast<int>(n));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

8
qt/gen_qtransposeproxymodel.cpp
View File

@ -163,15 +163,15 @@ void QTransposeProxyModel_TrUtf83(const char* s, const char* c, int n, char** _o
}
int QTransposeProxyModel_RowCount1(QTransposeProxyModel* self, QModelIndex* parent) {
return self->rowCount(*parent);
return const_cast<const QTransposeProxyModel*>(self)->rowCount(*parent);
}
int QTransposeProxyModel_ColumnCount1(QTransposeProxyModel* self, QModelIndex* parent) {
return self->columnCount(*parent);
return const_cast<const QTransposeProxyModel*>(self)->columnCount(*parent);
}
QVariant* QTransposeProxyModel_HeaderData3(QTransposeProxyModel* self, int section, uintptr_t orientation, int role) {
QVariant ret = self->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
QVariant ret = const_cast<const QTransposeProxyModel*>(self)->headerData(static_cast<int>(section), static_cast<Qt::Orientation>(orientation), static_cast<int>(role));
// Copy-construct value returned type into heap-allocated copy
return static_cast<QVariant*>(new QVariant(ret));
}
@ -181,7 +181,7 @@ bool QTransposeProxyModel_SetHeaderData4(QTransposeProxyModel* self, int section
}
QModelIndex* QTransposeProxyModel_Index3(QTransposeProxyModel* self, int row, int column, QModelIndex* parent) {
QModelIndex ret = self->index(static_cast<int>(row), static_cast<int>(column), *parent);
QModelIndex ret = const_cast<const QTransposeProxyModel*>(self)->index(static_cast<int>(row), static_cast<int>(column), *parent);
// Copy-construct value returned type into heap-allocated copy
return static_cast<QModelIndex*>(new QModelIndex(ret));
}

4
qt/gen_qtreewidget.cpp
View File

@ -842,12 +842,12 @@ void QTreeWidget_ClosePersistentEditor2(QTreeWidget* self, QTreeWidgetItem* item
}
bool QTreeWidget_IsPersistentEditorOpen2(QTreeWidget* self, QTreeWidgetItem* item, int column) {
return self->isPersistentEditorOpen(item, static_cast<int>(column));
return const_cast<const QTreeWidget*>(self)->isPersistentEditorOpen(item, static_cast<int>(column));
}
void QTreeWidget_FindItems3(QTreeWidget* self, const char* text, size_t text_Strlen, int flags, int column, QTreeWidgetItem*** _out, size_t* _out_len) {
QString text_QString = QString::fromUtf8(text, text_Strlen);
QList<QTreeWidgetItem*> ret = self->findItems(text_QString, static_cast<Qt::MatchFlags>(flags), static_cast<int>(column));
QList<QTreeWidgetItem*> ret = const_cast<const QTreeWidget*>(self)->findItems(text_QString, static_cast<Qt::MatchFlags>(flags), static_cast<int>(column));
// Convert QList<> from C++ memory to manually-managed C memory
QTreeWidgetItem** __out = static_cast<QTreeWidgetItem**>(malloc(sizeof(QTreeWidgetItem*) * ret.length()));
for (size_t i = 0, e = ret.length(); i < e; ++i) {

4
qt/gen_qundogroup.cpp
View File

@ -228,12 +228,12 @@ void QUndoGroup_TrUtf83(const char* s, const char* c, int n, char** _out, int* _
QAction* QUndoGroup_CreateUndoAction2(QUndoGroup* self, QObject* parent, const char* prefix, size_t prefix_Strlen) {
QString prefix_QString = QString::fromUtf8(prefix, prefix_Strlen);
return self->createUndoAction(parent, prefix_QString);
return const_cast<const QUndoGroup*>(self)->createUndoAction(parent, prefix_QString);
}
QAction* QUndoGroup_CreateRedoAction2(QUndoGroup* self, QObject* parent, const char* prefix, size_t prefix_Strlen) {
QString prefix_QString = QString::fromUtf8(prefix, prefix_Strlen);
return self->createRedoAction(parent, prefix_QString);
return const_cast<const QUndoGroup*>(self)->createRedoAction(parent, prefix_QString);
}
void QUndoGroup_Delete(QUndoGroup* self) {

4
qt/gen_qundostack.cpp
View File

@ -337,12 +337,12 @@ void QUndoStack_TrUtf83(const char* s, const char* c, int n, char** _out, int* _
QAction* QUndoStack_CreateUndoAction2(QUndoStack* self, QObject* parent, const char* prefix, size_t prefix_Strlen) {
QString prefix_QString = QString::fromUtf8(prefix, prefix_Strlen);
return self->createUndoAction(parent, prefix_QString);
return const_cast<const QUndoStack*>(self)->createUndoAction(parent, prefix_QString);
}
QAction* QUndoStack_CreateRedoAction2(QUndoStack* self, QObject* parent, const char* prefix, size_t prefix_Strlen) {
QString prefix_QString = QString::fromUtf8(prefix, prefix_Strlen);
return self->createRedoAction(parent, prefix_QString);
return const_cast<const QUndoStack*>(self)->createRedoAction(parent, prefix_QString);
}
void QUndoStack_SetActive1(QUndoStack* self, bool active) {

22
qt/gen_qurl.cpp
View File

@ -463,7 +463,7 @@ void QUrl_SetAuthority2(QUrl* self, const char* authority, size_t authority_Strl
}
void QUrl_Authority1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->authority(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->authority(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -477,7 +477,7 @@ void QUrl_SetUserInfo2(QUrl* self, const char* userInfo, size_t userInfo_Strlen,
}
void QUrl_UserInfo1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->userInfo(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->userInfo(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -491,7 +491,7 @@ void QUrl_SetUserName2(QUrl* self, const char* userName, size_t userName_Strlen,
}
void QUrl_UserName1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->userName(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->userName(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -505,7 +505,7 @@ void QUrl_SetPassword2(QUrl* self, const char* password, size_t password_Strlen,
}
void QUrl_Password1(QUrl* self, int param1, char** _out, int* _out_Strlen) {
QString ret = self->password(static_cast<QUrl::ComponentFormattingOptions>(param1));
QString ret = const_cast<const QUrl*>(self)->password(static_cast<QUrl::ComponentFormattingOptions>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -519,7 +519,7 @@ void QUrl_SetHost2(QUrl* self, const char* host, size_t host_Strlen, uintptr_t m
}
void QUrl_Host1(QUrl* self, int param1, char** _out, int* _out_Strlen) {
QString ret = self->host(static_cast<QUrl::ComponentFormattingOptions>(param1));
QString ret = const_cast<const QUrl*>(self)->host(static_cast<QUrl::ComponentFormattingOptions>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -528,7 +528,7 @@ void QUrl_Host1(QUrl* self, int param1, char** _out, int* _out_Strlen) {
}
void QUrl_TopLevelDomain1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->topLevelDomain(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->topLevelDomain(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -537,7 +537,7 @@ void QUrl_TopLevelDomain1(QUrl* self, int options, char** _out, int* _out_Strlen
}
int QUrl_Port1(QUrl* self, int defaultPort) {
return self->port(static_cast<int>(defaultPort));
return const_cast<const QUrl*>(self)->port(static_cast<int>(defaultPort));
}
void QUrl_SetPath2(QUrl* self, const char* path, size_t path_Strlen, uintptr_t mode) {
@ -546,7 +546,7 @@ void QUrl_SetPath2(QUrl* self, const char* path, size_t path_Strlen, uintptr_t m
}
void QUrl_Path1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->path(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->path(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -555,7 +555,7 @@ void QUrl_Path1(QUrl* self, int options, char** _out, int* _out_Strlen) {
}
void QUrl_FileName1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->fileName(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->fileName(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -569,7 +569,7 @@ void QUrl_SetQuery2(QUrl* self, const char* query, size_t query_Strlen, uintptr_
}
void QUrl_Query1(QUrl* self, int param1, char** _out, int* _out_Strlen) {
QString ret = self->query(static_cast<QUrl::ComponentFormattingOptions>(param1));
QString ret = const_cast<const QUrl*>(self)->query(static_cast<QUrl::ComponentFormattingOptions>(param1));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -578,7 +578,7 @@ void QUrl_Query1(QUrl* self, int param1, char** _out, int* _out_Strlen) {
}
void QUrl_Fragment1(QUrl* self, int options, char** _out, int* _out_Strlen) {
QString ret = self->fragment(static_cast<QUrl::ComponentFormattingOptions>(options));
QString ret = const_cast<const QUrl*>(self)->fragment(static_cast<QUrl::ComponentFormattingOptions>(options));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));

8
qt/gen_qurlquery.cpp
View File

@ -159,7 +159,7 @@ QChar* QUrlQuery_DefaultQueryPairDelimiter() {
}
void QUrlQuery_Query1(QUrlQuery* self, int encoding, char** _out, int* _out_Strlen) {
QString ret = self->query(static_cast<QUrl::ComponentFormattingOptions>(encoding));
QString ret = const_cast<const QUrlQuery*>(self)->query(static_cast<QUrl::ComponentFormattingOptions>(encoding));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -168,7 +168,7 @@ void QUrlQuery_Query1(QUrlQuery* self, int encoding, char** _out, int* _out_Strl
}
void QUrlQuery_ToString1(QUrlQuery* self, int encoding, char** _out, int* _out_Strlen) {
QString ret = self->toString(static_cast<QUrl::ComponentFormattingOptions>(encoding));
QString ret = const_cast<const QUrlQuery*>(self)->toString(static_cast<QUrl::ComponentFormattingOptions>(encoding));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -178,7 +178,7 @@ void QUrlQuery_ToString1(QUrlQuery* self, int encoding, char** _out, int* _out_S
void QUrlQuery_QueryItemValue2(QUrlQuery* self, const char* key, size_t key_Strlen, int encoding, char** _out, int* _out_Strlen) {
QString key_QString = QString::fromUtf8(key, key_Strlen);
QString ret = self->queryItemValue(key_QString, static_cast<QUrl::ComponentFormattingOptions>(encoding));
QString ret = const_cast<const QUrlQuery*>(self)->queryItemValue(key_QString, static_cast<QUrl::ComponentFormattingOptions>(encoding));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray b = ret.toUtf8();
*_out = static_cast<char*>(malloc(b.length()));
@ -188,7 +188,7 @@ void QUrlQuery_QueryItemValue2(QUrlQuery* self, const char* key, size_t key_Strl
void QUrlQuery_AllQueryItemValues2(QUrlQuery* self, const char* key, size_t key_Strlen, int encoding, char*** _out, int** _out_Lengths, size_t* _out_len) {
QString key_QString = QString::fromUtf8(key, key_Strlen);
QStringList ret = self->allQueryItemValues(key_QString, static_cast<QUrl::ComponentFormattingOptions>(encoding));
QStringList ret = const_cast<const QUrlQuery*>(self)->allQueryItemValues(key_QString, static_cast<QUrl::ComponentFormattingOptions>(encoding));
// Convert QStringList from C++ memory to manually-managed C memory
char** __out = static_cast<char**>(malloc(sizeof(char*) * ret.length()));
int* __out_Lengths = static_cast<int*>(malloc(sizeof(int) * ret.length()));

Some files were not shown because too many files have changed in this diff Show More