qt: rebuild (extended subclassing support)

qt-extras/scintillaedit/gen_ScintillaEdit.h

@@ -432,6 +432,7 @@ void Scintilla__Internal__SurfaceMode_new(Scintilla__Internal__SurfaceMode** out
 void Scintilla__Internal__SurfaceMode_new2(int codePage_, bool bidiR2L_, Scintilla__Internal__SurfaceMode** outptr_Scintilla__Internal__SurfaceMode);
 void Scintilla__Internal__SurfaceMode_Delete(Scintilla__Internal__SurfaceMode* self, bool isSubclass);
 
+void Scintilla__Internal__Surface_new(Scintilla__Internal__Surface** outptr_Scintilla__Internal__Surface);
 void Scintilla__Internal__Surface_Init(Scintilla__Internal__Surface* self, void* wid);
 void Scintilla__Internal__Surface_Init2(Scintilla__Internal__Surface* self, void* sid, void* wid);
 void Scintilla__Internal__Surface_SetMode(Scintilla__Internal__Surface* self, Scintilla__Internal__SurfaceMode* mode);
@@ -464,6 +465,70 @@ void Scintilla__Internal__Surface_SetClip(Scintilla__Internal__Surface* self, Sc
 void Scintilla__Internal__Surface_PopClip(Scintilla__Internal__Surface* self);
 void Scintilla__Internal__Surface_FlushCachedState(Scintilla__Internal__Surface* self);
 void Scintilla__Internal__Surface_FlushDrawing(Scintilla__Internal__Surface* self);
+void Scintilla__Internal__Surface_override_virtual_Init(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Init(void* self, void* wid);
+void Scintilla__Internal__Surface_override_virtual_Init2(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Init2(void* self, void* sid, void* wid);
+void Scintilla__Internal__Surface_override_virtual_SetMode(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_SetMode(void* self, Scintilla__Internal__SurfaceMode* mode);
+void Scintilla__Internal__Surface_override_virtual_Release(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Release(void* self);
+void Scintilla__Internal__Surface_override_virtual_SupportsFeature(void* self, intptr_t slot);
+int Scintilla__Internal__Surface_virtualbase_SupportsFeature(void* self, int feature);
+void Scintilla__Internal__Surface_override_virtual_Initialised(void* self, intptr_t slot);
+bool Scintilla__Internal__Surface_virtualbase_Initialised(void* self);
+void Scintilla__Internal__Surface_override_virtual_LogPixelsY(void* self, intptr_t slot);
+int Scintilla__Internal__Surface_virtualbase_LogPixelsY(void* self);
+void Scintilla__Internal__Surface_override_virtual_PixelDivisions(void* self, intptr_t slot);
+int Scintilla__Internal__Surface_virtualbase_PixelDivisions(void* self);
+void Scintilla__Internal__Surface_override_virtual_DeviceHeightFont(void* self, intptr_t slot);
+int Scintilla__Internal__Surface_virtualbase_DeviceHeightFont(void* self, int points);
+void Scintilla__Internal__Surface_override_virtual_LineDraw(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_LineDraw(void* self, Scintilla__Internal__Point* start, Scintilla__Internal__Point* end, Scintilla__Internal__Stroke* stroke);
+void Scintilla__Internal__Surface_override_virtual_PolyLine(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_PolyLine(void* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__Stroke* stroke);
+void Scintilla__Internal__Surface_override_virtual_Polygon(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Polygon(void* self, Scintilla__Internal__Point* pts, size_t npts, Scintilla__Internal__FillStroke* fillStroke);
+void Scintilla__Internal__Surface_override_virtual_RectangleDraw(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_RectangleDraw(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke);
+void Scintilla__Internal__Surface_override_virtual_RectangleFrame(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_RectangleFrame(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Stroke* stroke);
+void Scintilla__Internal__Surface_override_virtual_FillRectangle(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_FillRectangle(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill);
+void Scintilla__Internal__Surface_override_virtual_FillRectangleAligned(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_FillRectangleAligned(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Fill* fill);
+void Scintilla__Internal__Surface_override_virtual_FillRectangle2(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_FillRectangle2(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Surface* surfacePattern);
+void Scintilla__Internal__Surface_override_virtual_RoundedRectangle(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_RoundedRectangle(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke);
+void Scintilla__Internal__Surface_override_virtual_AlphaRectangle(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_AlphaRectangle(void* self, Scintilla__Internal__PRectangle* rc, double cornerSize, Scintilla__Internal__FillStroke* fillStroke);
+void Scintilla__Internal__Surface_override_virtual_DrawRGBAImage(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_DrawRGBAImage(void* self, Scintilla__Internal__PRectangle* rc, int width, int height, const unsigned char* pixelsImage);
+void Scintilla__Internal__Surface_override_virtual_Ellipse(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Ellipse(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke);
+void Scintilla__Internal__Surface_override_virtual_Stadium(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Stadium(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__FillStroke* fillStroke, int ends);
+void Scintilla__Internal__Surface_override_virtual_Copy(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_Copy(void* self, Scintilla__Internal__PRectangle* rc, Scintilla__Internal__Point* from, Scintilla__Internal__Surface* surfaceSource);
+void Scintilla__Internal__Surface_override_virtual_Ascent(void* self, intptr_t slot);
+double Scintilla__Internal__Surface_virtualbase_Ascent(void* self, Scintilla__Internal__Font* font_);
+void Scintilla__Internal__Surface_override_virtual_Descent(void* self, intptr_t slot);
+double Scintilla__Internal__Surface_virtualbase_Descent(void* self, Scintilla__Internal__Font* font_);
+void Scintilla__Internal__Surface_override_virtual_InternalLeading(void* self, intptr_t slot);
+double Scintilla__Internal__Surface_virtualbase_InternalLeading(void* self, Scintilla__Internal__Font* font_);
+void Scintilla__Internal__Surface_override_virtual_Height(void* self, intptr_t slot);
+double Scintilla__Internal__Surface_virtualbase_Height(void* self, Scintilla__Internal__Font* font_);
+void Scintilla__Internal__Surface_override_virtual_AverageCharWidth(void* self, intptr_t slot);
+double Scintilla__Internal__Surface_virtualbase_AverageCharWidth(void* self, Scintilla__Internal__Font* font_);
+void Scintilla__Internal__Surface_override_virtual_SetClip(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_SetClip(void* self, Scintilla__Internal__PRectangle* rc);
+void Scintilla__Internal__Surface_override_virtual_PopClip(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_PopClip(void* self);
+void Scintilla__Internal__Surface_override_virtual_FlushCachedState(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_FlushCachedState(void* self);
+void Scintilla__Internal__Surface_override_virtual_FlushDrawing(void* self, intptr_t slot);
+void Scintilla__Internal__Surface_virtualbase_FlushDrawing(void* self);
 void Scintilla__Internal__Surface_Delete(Scintilla__Internal__Surface* self, bool isSubclass);
 
 void Scintilla__Internal__Window_new(Scintilla__Internal__Window** outptr_Scintilla__Internal__Window);
@@ -492,6 +557,7 @@ void Scintilla__Internal__IListBoxDelegate_Delete(Scintilla__Internal__IListBoxD
 
 void Scintilla__Internal__ListOptions_Delete(Scintilla__Internal__ListOptions* self, bool isSubclass);
 
+void Scintilla__Internal__ListBox_new(Scintilla__Internal__ListBox** outptr_Scintilla__Internal__ListBox, Scintilla__Internal__Window** outptr_Scintilla__Internal__Window);
 void Scintilla__Internal__ListBox_SetFont(Scintilla__Internal__ListBox* self, Scintilla__Internal__Font* font);
 void Scintilla__Internal__ListBox_Create(Scintilla__Internal__ListBox* self, Scintilla__Internal__Window* parent, int ctrlID, Scintilla__Internal__Point* location, int lineHeight_, bool unicodeMode_, int technology_);
 void Scintilla__Internal__ListBox_SetAverageCharWidth(Scintilla__Internal__ListBox* self, int width);
@@ -511,6 +577,44 @@ void Scintilla__Internal__ListBox_ClearRegisteredImages(Scintilla__Internal__Lis
 void Scintilla__Internal__ListBox_SetDelegate(Scintilla__Internal__ListBox* self, Scintilla__Internal__IListBoxDelegate* lbDelegate);
 void Scintilla__Internal__ListBox_SetList(Scintilla__Internal__ListBox* self, const char* list, char separator, char typesep);
 void Scintilla__Internal__ListBox_SetOptions(Scintilla__Internal__ListBox* self, Scintilla__Internal__ListOptions* options_);
+void Scintilla__Internal__ListBox_override_virtual_SetFont(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetFont(void* self, Scintilla__Internal__Font* font);
+void Scintilla__Internal__ListBox_override_virtual_Create(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_Create(void* self, Scintilla__Internal__Window* parent, int ctrlID, Scintilla__Internal__Point* location, int lineHeight_, bool unicodeMode_, int technology_);
+void Scintilla__Internal__ListBox_override_virtual_SetAverageCharWidth(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetAverageCharWidth(void* self, int width);
+void Scintilla__Internal__ListBox_override_virtual_SetVisibleRows(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetVisibleRows(void* self, int rows);
+void Scintilla__Internal__ListBox_override_virtual_GetVisibleRows(void* self, intptr_t slot);
+int Scintilla__Internal__ListBox_virtualbase_GetVisibleRows(const void* self);
+void Scintilla__Internal__ListBox_override_virtual_GetDesiredRect(void* self, intptr_t slot);
+Scintilla__Internal__PRectangle* Scintilla__Internal__ListBox_virtualbase_GetDesiredRect(void* self);
+void Scintilla__Internal__ListBox_override_virtual_CaretFromEdge(void* self, intptr_t slot);
+int Scintilla__Internal__ListBox_virtualbase_CaretFromEdge(void* self);
+void Scintilla__Internal__ListBox_override_virtual_Clear(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_Clear(void* self);
+void Scintilla__Internal__ListBox_override_virtual_Append(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_Append(void* self, char* s, int typeVal);
+void Scintilla__Internal__ListBox_override_virtual_Length(void* self, intptr_t slot);
+int Scintilla__Internal__ListBox_virtualbase_Length(void* self);
+void Scintilla__Internal__ListBox_override_virtual_Select(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_Select(void* self, int n);
+void Scintilla__Internal__ListBox_override_virtual_GetSelection(void* self, intptr_t slot);
+int Scintilla__Internal__ListBox_virtualbase_GetSelection(void* self);
+void Scintilla__Internal__ListBox_override_virtual_Find(void* self, intptr_t slot);
+int Scintilla__Internal__ListBox_virtualbase_Find(void* self, const char* prefix);
+void Scintilla__Internal__ListBox_override_virtual_RegisterImage(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_RegisterImage(void* self, int typeVal, const char* xpm_data);
+void Scintilla__Internal__ListBox_override_virtual_RegisterRGBAImage(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_RegisterRGBAImage(void* self, int typeVal, int width, int height, const unsigned char* pixelsImage);
+void Scintilla__Internal__ListBox_override_virtual_ClearRegisteredImages(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_ClearRegisteredImages(void* self);
+void Scintilla__Internal__ListBox_override_virtual_SetDelegate(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetDelegate(void* self, Scintilla__Internal__IListBoxDelegate* lbDelegate);
+void Scintilla__Internal__ListBox_override_virtual_SetList(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetList(void* self, const char* list, char separator, char typesep);
+void Scintilla__Internal__ListBox_override_virtual_SetOptions(void* self, intptr_t slot);
+void Scintilla__Internal__ListBox_virtualbase_SetOptions(void* self, Scintilla__Internal__ListOptions* options_);
 void Scintilla__Internal__ListBox_Delete(Scintilla__Internal__ListBox* self, bool isSubclass);
 
 void Scintilla__Internal__Menu_new(Scintilla__Internal__Menu** outptr_Scintilla__Internal__Menu);

qt-restricted-extras/qscintilla/gen_qsciabstractapis.cpp

@@ -1,13 +1,336 @@
+#include <QChildEvent>
+#include <QEvent>
 #include <QList>
+#include <QMetaMethod>
 #include <QMetaObject>
 #include <QObject>
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QTimerEvent>
 #include <qsciabstractapis.h>
 #include "gen_qsciabstractapis.h"
 #include "_cgo_export.h"
 
+class MiqtVirtualQsciAbstractAPIs : public virtual QsciAbstractAPIs {
+public:
+
+	MiqtVirtualQsciAbstractAPIs(QsciLexer* lexer): QsciAbstractAPIs(lexer) {};
+
+	virtual ~MiqtVirtualQsciAbstractAPIs() = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateAutoCompletionList = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateAutoCompletionList(const QStringList& context, QStringList& list) override {
+		if (handle__UpdateAutoCompletionList == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		const QStringList& context_ret = context;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* context_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * context_ret.length()));
+		for (size_t i = 0, e = context_ret.length(); i < e; ++i) {
+			QString context_lv_ret = context_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray context_lv_b = context_lv_ret.toUtf8();
+			struct miqt_string context_lv_ms;
+			context_lv_ms.len = context_lv_b.length();
+			context_lv_ms.data = static_cast<char*>(malloc(context_lv_ms.len));
+			memcpy(context_lv_ms.data, context_lv_b.data(), context_lv_ms.len);
+			context_arr[i] = context_lv_ms;
+		}
+		struct miqt_array context_out;
+		context_out.len = context_ret.length();
+		context_out.data = static_cast<void*>(context_arr);
+		struct miqt_array /* of struct miqt_string */  sigval1 = context_out;
+		QStringList& list_ret = list;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* list_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * list_ret.length()));
+		for (size_t i = 0, e = list_ret.length(); i < e; ++i) {
+			QString list_lv_ret = list_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray list_lv_b = list_lv_ret.toUtf8();
+			struct miqt_string list_lv_ms;
+			list_lv_ms.len = list_lv_b.length();
+			list_lv_ms.data = static_cast<char*>(malloc(list_lv_ms.len));
+			memcpy(list_lv_ms.data, list_lv_b.data(), list_lv_ms.len);
+			list_arr[i] = list_lv_ms;
+		}
+		struct miqt_array list_out;
+		list_out.len = list_ret.length();
+		list_out.data = static_cast<void*>(list_arr);
+		struct miqt_array /* of struct miqt_string */  sigval2 = list_out;
+
+		miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList(this, handle__UpdateAutoCompletionList, sigval1, sigval2);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__AutoCompletionSelected = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void autoCompletionSelected(const QString& selection) override {
+		if (handle__AutoCompletionSelected == 0) {
+			QsciAbstractAPIs::autoCompletionSelected(selection);
+			return;
+		}
+		
+		const QString selection_ret = selection;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray selection_b = selection_ret.toUtf8();
+		struct miqt_string selection_ms;
+		selection_ms.len = selection_b.length();
+		selection_ms.data = static_cast<char*>(malloc(selection_ms.len));
+		memcpy(selection_ms.data, selection_b.data(), selection_ms.len);
+		struct miqt_string sigval1 = selection_ms;
+
+		miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected(this, handle__AutoCompletionSelected, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_AutoCompletionSelected(struct miqt_string selection) {
+		QString selection_QString = QString::fromUtf8(selection.data, selection.len);
+
+		QsciAbstractAPIs::autoCompletionSelected(selection_QString);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CallTips = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QStringList callTips(const QStringList& context, int commas, QsciScintilla::CallTipsStyle style, QList<int>& shifts) override {
+		if (handle__CallTips == 0) {
+			return QStringList(); // Pure virtual, there is no base we can call
+		}
+		
+		const QStringList& context_ret = context;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* context_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * context_ret.length()));
+		for (size_t i = 0, e = context_ret.length(); i < e; ++i) {
+			QString context_lv_ret = context_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray context_lv_b = context_lv_ret.toUtf8();
+			struct miqt_string context_lv_ms;
+			context_lv_ms.len = context_lv_b.length();
+			context_lv_ms.data = static_cast<char*>(malloc(context_lv_ms.len));
+			memcpy(context_lv_ms.data, context_lv_b.data(), context_lv_ms.len);
+			context_arr[i] = context_lv_ms;
+		}
+		struct miqt_array context_out;
+		context_out.len = context_ret.length();
+		context_out.data = static_cast<void*>(context_arr);
+		struct miqt_array /* of struct miqt_string */  sigval1 = context_out;
+		int sigval2 = commas;
+		QsciScintilla::CallTipsStyle style_ret = style;
+		int sigval3 = static_cast<int>(style_ret);
+		QList<int>& shifts_ret = shifts;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		int* shifts_arr = static_cast<int*>(malloc(sizeof(int) * shifts_ret.length()));
+		for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) {
+			shifts_arr[i] = shifts_ret[i];
+		}
+		struct miqt_array shifts_out;
+		shifts_out.len = shifts_ret.length();
+		shifts_out.data = static_cast<void*>(shifts_arr);
+		struct miqt_array /* of int */  sigval4 = shifts_out;
+
+		struct miqt_array /* of struct miqt_string */  callback_return_value = miqt_exec_callback_QsciAbstractAPIs_CallTips(this, handle__CallTips, sigval1, sigval2, sigval3, sigval4);
+		QStringList callback_return_value_QList;
+		callback_return_value_QList.reserve(callback_return_value.len);
+		struct miqt_string* callback_return_value_arr = static_cast<struct miqt_string*>(callback_return_value.data);
+		for(size_t i = 0; i < callback_return_value.len; ++i) {
+			QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len);
+			callback_return_value_QList.push_back(callback_return_value_arr_i_QString);
+		}
+
+		return callback_return_value_QList;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__Event == 0) {
+			return QsciAbstractAPIs::event(event);
+		}
+		
+		QEvent* sigval1 = event;
+
+		bool callback_return_value = miqt_exec_callback_QsciAbstractAPIs_Event(this, handle__Event, sigval1);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_Event(QEvent* event) {
+
+		return QsciAbstractAPIs::event(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__EventFilter == 0) {
+			return QsciAbstractAPIs::eventFilter(watched, event);
+		}
+		
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+
+		bool callback_return_value = miqt_exec_callback_QsciAbstractAPIs_EventFilter(this, handle__EventFilter, sigval1, sigval2);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
+
+		return QsciAbstractAPIs::eventFilter(watched, event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__TimerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__TimerEvent == 0) {
+			QsciAbstractAPIs::timerEvent(event);
+			return;
+		}
+		
+		QTimerEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_TimerEvent(this, handle__TimerEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_TimerEvent(QTimerEvent* event) {
+
+		QsciAbstractAPIs::timerEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ChildEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__ChildEvent == 0) {
+			QsciAbstractAPIs::childEvent(event);
+			return;
+		}
+		
+		QChildEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_ChildEvent(this, handle__ChildEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ChildEvent(QChildEvent* event) {
+
+		QsciAbstractAPIs::childEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CustomEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__CustomEvent == 0) {
+			QsciAbstractAPIs::customEvent(event);
+			return;
+		}
+		
+		QEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_CustomEvent(this, handle__CustomEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_CustomEvent(QEvent* event) {
+
+		QsciAbstractAPIs::customEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ConnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__ConnectNotify == 0) {
+			QsciAbstractAPIs::connectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QsciAbstractAPIs_ConnectNotify(this, handle__ConnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ConnectNotify(QMetaMethod* signal) {
+
+		QsciAbstractAPIs::connectNotify(*signal);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DisconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__DisconnectNotify == 0) {
+			QsciAbstractAPIs::disconnectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DisconnectNotify(QMetaMethod* signal) {
+
+		QsciAbstractAPIs::disconnectNotify(*signal);
+
+	}
+
+};
+
+void QsciAbstractAPIs_new(QsciLexer* lexer, QsciAbstractAPIs** outptr_QsciAbstractAPIs, QObject** outptr_QObject) {
+	MiqtVirtualQsciAbstractAPIs* ret = new MiqtVirtualQsciAbstractAPIs(lexer);
+	*outptr_QsciAbstractAPIs = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
 QMetaObject* QsciAbstractAPIs_MetaObject(const QsciAbstractAPIs* self) {
 	return (QMetaObject*) self->metaObject();
 }
@@ -142,9 +465,81 @@ struct miqt_string QsciAbstractAPIs_TrUtf83(const char* s, const char* c, int n)
 	return _ms;
 }
 
+void QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__UpdateAutoCompletionList = slot;
+}
+
+void QsciAbstractAPIs_override_virtual_AutoCompletionSelected(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__AutoCompletionSelected = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_AutoCompletionSelected(void* self, struct miqt_string selection) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_AutoCompletionSelected(selection);
+}
+
+void QsciAbstractAPIs_override_virtual_CallTips(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__CallTips = slot;
+}
+
+void QsciAbstractAPIs_override_virtual_Event(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__Event = slot;
+}
+
+bool QsciAbstractAPIs_virtualbase_Event(void* self, QEvent* event) {
+	return ( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_Event(event);
+}
+
+void QsciAbstractAPIs_override_virtual_EventFilter(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__EventFilter = slot;
+}
+
+bool QsciAbstractAPIs_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
+	return ( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_EventFilter(watched, event);
+}
+
+void QsciAbstractAPIs_override_virtual_TimerEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__TimerEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_TimerEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_ChildEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__ChildEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_ChildEvent(void* self, QChildEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_ChildEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_CustomEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__CustomEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_CustomEvent(void* self, QEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_CustomEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_ConnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__ConnectNotify = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_ConnectNotify(signal);
+}
+
+void QsciAbstractAPIs_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__DisconnectNotify = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_DisconnectNotify(signal);
+}
+
 void QsciAbstractAPIs_Delete(QsciAbstractAPIs* self, bool isSubclass) {
 	if (isSubclass) {
-		delete dynamic_cast<QsciAbstractAPIs*>( self );
+		delete dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( self );
 	} else {
 		delete self;
 	}

qt-restricted-extras/qscintilla/gen_qsciabstractapis.go

@@ -11,6 +11,7 @@ import "C"
 import (
 	"github.com/mappu/miqt/qt"
 	"runtime"
+	"runtime/cgo"
 	"unsafe"
 )
 
@@ -53,6 +54,17 @@ func UnsafeNewQsciAbstractAPIs(h unsafe.Pointer, h_QObject unsafe.Pointer) *Qsci
 		QObject: qt.UnsafeNewQObject(h_QObject)}
 }
 
+// NewQsciAbstractAPIs constructs a new QsciAbstractAPIs object.
+func NewQsciAbstractAPIs(lexer *QsciLexer) *QsciAbstractAPIs {
+	var outptr_QsciAbstractAPIs *C.QsciAbstractAPIs = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciAbstractAPIs_new(lexer.cPointer(), &outptr_QsciAbstractAPIs, &outptr_QObject)
+	ret := newQsciAbstractAPIs(outptr_QsciAbstractAPIs, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QsciAbstractAPIs) MetaObject() *qt.QMetaObject {
 	return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QsciAbstractAPIs_MetaObject(this.h)))
 }
@@ -189,6 +201,289 @@ func QsciAbstractAPIs_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
+func (this *QsciAbstractAPIs) OnUpdateAutoCompletionList(slot func(context []string, list []string)) {
+	C.QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList
+func miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList(self *C.QsciAbstractAPIs, cb C.intptr_t, context C.struct_miqt_array, list C.struct_miqt_array) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(context []string, list []string))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var context_ma C.struct_miqt_array = context
+	context_ret := make([]string, int(context_ma.len))
+	context_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(context_ma.data)) // hey ya
+	for i := 0; i < int(context_ma.len); i++ {
+		var context_lv_ms C.struct_miqt_string = context_outCast[i]
+		context_lv_ret := C.GoStringN(context_lv_ms.data, C.int(int64(context_lv_ms.len)))
+		C.free(unsafe.Pointer(context_lv_ms.data))
+		context_ret[i] = context_lv_ret
+	}
+	slotval1 := context_ret
+
+	var list_ma C.struct_miqt_array = list
+	list_ret := make([]string, int(list_ma.len))
+	list_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(list_ma.data)) // hey ya
+	for i := 0; i < int(list_ma.len); i++ {
+		var list_lv_ms C.struct_miqt_string = list_outCast[i]
+		list_lv_ret := C.GoStringN(list_lv_ms.data, C.int(int64(list_lv_ms.len)))
+		C.free(unsafe.Pointer(list_lv_ms.data))
+		list_ret[i] = list_lv_ret
+	}
+	slotval2 := list_ret
+
+	gofunc(slotval1, slotval2)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_AutoCompletionSelected(selection string) {
+	selection_ms := C.struct_miqt_string{}
+	selection_ms.data = C.CString(selection)
+	selection_ms.len = C.size_t(len(selection))
+	defer C.free(unsafe.Pointer(selection_ms.data))
+
+	C.QsciAbstractAPIs_virtualbase_AutoCompletionSelected(unsafe.Pointer(this.h), selection_ms)
+
+}
+func (this *QsciAbstractAPIs) OnAutoCompletionSelected(slot func(super func(selection string), selection string)) {
+	C.QsciAbstractAPIs_override_virtual_AutoCompletionSelected(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected
+func miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected(self *C.QsciAbstractAPIs, cb C.intptr_t, selection C.struct_miqt_string) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(selection string), selection string))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var selection_ms C.struct_miqt_string = selection
+	selection_ret := C.GoStringN(selection_ms.data, C.int(int64(selection_ms.len)))
+	C.free(unsafe.Pointer(selection_ms.data))
+	slotval1 := selection_ret
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_AutoCompletionSelected, slotval1)
+
+}
+func (this *QsciAbstractAPIs) OnCallTips(slot func(context []string, commas int, style QsciScintilla__CallTipsStyle, shifts []int) []string) {
+	C.QsciAbstractAPIs_override_virtual_CallTips(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_CallTips
+func miqt_exec_callback_QsciAbstractAPIs_CallTips(self *C.QsciAbstractAPIs, cb C.intptr_t, context C.struct_miqt_array, commas C.int, style C.int, shifts C.struct_miqt_array) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(context []string, commas int, style QsciScintilla__CallTipsStyle, shifts []int) []string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var context_ma C.struct_miqt_array = context
+	context_ret := make([]string, int(context_ma.len))
+	context_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(context_ma.data)) // hey ya
+	for i := 0; i < int(context_ma.len); i++ {
+		var context_lv_ms C.struct_miqt_string = context_outCast[i]
+		context_lv_ret := C.GoStringN(context_lv_ms.data, C.int(int64(context_lv_ms.len)))
+		C.free(unsafe.Pointer(context_lv_ms.data))
+		context_ret[i] = context_lv_ret
+	}
+	slotval1 := context_ret
+
+	slotval2 := (int)(commas)
+
+	slotval3 := (QsciScintilla__CallTipsStyle)(style)
+
+	var shifts_ma C.struct_miqt_array = shifts
+	shifts_ret := make([]int, int(shifts_ma.len))
+	shifts_outCast := (*[0xffff]C.int)(unsafe.Pointer(shifts_ma.data)) // hey ya
+	for i := 0; i < int(shifts_ma.len); i++ {
+		shifts_ret[i] = (int)(shifts_outCast[i])
+	}
+	slotval4 := shifts_ret
+
+	virtualReturn := gofunc(slotval1, slotval2, slotval3, slotval4)
+	virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_i_ms := C.struct_miqt_string{}
+		virtualReturn_i_ms.data = C.CString(virtualReturn[i])
+		virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i]))
+		defer C.free(unsafe.Pointer(virtualReturn_i_ms.data))
+		virtualReturn_CArray[i] = virtualReturn_i_ms
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_Event(event *qt.QEvent) bool {
+
+	return (bool)(C.QsciAbstractAPIs_virtualbase_Event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QsciAbstractAPIs) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) {
+	C.QsciAbstractAPIs_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_Event
+func miqt_exec_callback_QsciAbstractAPIs_Event(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool {
+
+	return (bool)(C.QsciAbstractAPIs_virtualbase_EventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QsciAbstractAPIs) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) {
+	C.QsciAbstractAPIs_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_EventFilter
+func miqt_exec_callback_QsciAbstractAPIs_EventFilter(self *C.QsciAbstractAPIs, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched))
+	slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_TimerEvent(event *qt.QTimerEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_TimerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) {
+	C.QsciAbstractAPIs_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_TimerEvent
+func miqt_exec_callback_QsciAbstractAPIs_TimerEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_ChildEvent(event *qt.QChildEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_ChildEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) {
+	C.QsciAbstractAPIs_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_ChildEvent
+func miqt_exec_callback_QsciAbstractAPIs_ChildEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_CustomEvent(event *qt.QEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_CustomEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) {
+	C.QsciAbstractAPIs_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_CustomEvent
+func miqt_exec_callback_QsciAbstractAPIs_CustomEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) {
+
+	C.QsciAbstractAPIs_virtualbase_ConnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
+	C.QsciAbstractAPIs_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_ConnectNotify
+func miqt_exec_callback_QsciAbstractAPIs_ConnectNotify(self *C.QsciAbstractAPIs, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) {
+
+	C.QsciAbstractAPIs_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
+	C.QsciAbstractAPIs_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify
+func miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify(self *C.QsciAbstractAPIs, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QsciAbstractAPIs) Delete() {

qt-restricted-extras/qscintilla/gen_qsciabstractapis.h

@@ -15,17 +15,26 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
 class QMetaObject;
 class QObject;
+class QTimerEvent;
 class QsciAbstractAPIs;
 class QsciLexer;
 #else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QsciAbstractAPIs QsciAbstractAPIs;
 typedef struct QsciLexer QsciLexer;
 #endif
 
+void QsciAbstractAPIs_new(QsciLexer* lexer, QsciAbstractAPIs** outptr_QsciAbstractAPIs, QObject** outptr_QObject);
 QMetaObject* QsciAbstractAPIs_MetaObject(const QsciAbstractAPIs* self);
 void* QsciAbstractAPIs_Metacast(QsciAbstractAPIs* self, const char* param1);
 struct miqt_string QsciAbstractAPIs_Tr(const char* s);
@@ -38,6 +47,26 @@ struct miqt_string QsciAbstractAPIs_Tr2(const char* s, const char* c);
 struct miqt_string QsciAbstractAPIs_Tr3(const char* s, const char* c, int n);
 struct miqt_string QsciAbstractAPIs_TrUtf82(const char* s, const char* c);
 struct miqt_string QsciAbstractAPIs_TrUtf83(const char* s, const char* c, int n);
+void QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_UpdateAutoCompletionList(void* self, struct miqt_array /* of struct miqt_string */  context, struct miqt_array /* of struct miqt_string */  list);
+void QsciAbstractAPIs_override_virtual_AutoCompletionSelected(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_AutoCompletionSelected(void* self, struct miqt_string selection);
+void QsciAbstractAPIs_override_virtual_CallTips(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciAbstractAPIs_virtualbase_CallTips(void* self, struct miqt_array /* of struct miqt_string */  context, int commas, int style, struct miqt_array /* of int */  shifts);
+void QsciAbstractAPIs_override_virtual_Event(void* self, intptr_t slot);
+bool QsciAbstractAPIs_virtualbase_Event(void* self, QEvent* event);
+void QsciAbstractAPIs_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QsciAbstractAPIs_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QsciAbstractAPIs_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QsciAbstractAPIs_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QsciAbstractAPIs_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_CustomEvent(void* self, QEvent* event);
+void QsciAbstractAPIs_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QsciAbstractAPIs_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QsciAbstractAPIs_Delete(QsciAbstractAPIs* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla/gen_qscilexer.h

@@ -15,25 +15,35 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QChildEvent;
 class QColor;
+class QEvent;
 class QFont;
+class QMetaMethod;
 class QMetaObject;
 class QObject;
 class QSettings;
+class QTimerEvent;
 class QsciAbstractAPIs;
 class QsciLexer;
 class QsciScintilla;
 #else
+typedef struct QChildEvent QChildEvent;
 typedef struct QColor QColor;
+typedef struct QEvent QEvent;
 typedef struct QFont QFont;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
 typedef struct QSettings QSettings;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QsciAbstractAPIs QsciAbstractAPIs;
 typedef struct QsciLexer QsciLexer;
 typedef struct QsciScintilla QsciScintilla;
 #endif
 
+void QsciLexer_new(QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
+void QsciLexer_new2(QObject* parent, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
 QMetaObject* QsciLexer_MetaObject(const QsciLexer* self);
 void* QsciLexer_Metacast(QsciLexer* self, const char* param1);
 struct miqt_string QsciLexer_Tr(const char* s);
@@ -100,6 +110,88 @@ struct miqt_string QsciLexer_TrUtf82(const char* s, const char* c);
 struct miqt_string QsciLexer_TrUtf83(const char* s, const char* c, int n);
 bool QsciLexer_ReadSettings2(QsciLexer* self, QSettings* qs, const char* prefix);
 bool QsciLexer_WriteSettings2(const QsciLexer* self, QSettings* qs, const char* prefix);
+void QsciLexer_override_virtual_Language(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Language(const void* self);
+void QsciLexer_override_virtual_Lexer(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Lexer(const void* self);
+void QsciLexer_override_virtual_LexerId(void* self, intptr_t slot);
+int QsciLexer_virtualbase_LexerId(const void* self);
+void QsciLexer_override_virtual_AutoCompletionFillups(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_AutoCompletionFillups(const void* self);
+void QsciLexer_override_virtual_AutoCompletionWordSeparators(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciLexer_virtualbase_AutoCompletionWordSeparators(const void* self);
+void QsciLexer_override_virtual_BlockEnd(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockEnd(const void* self, int* style);
+void QsciLexer_override_virtual_BlockLookback(void* self, intptr_t slot);
+int QsciLexer_virtualbase_BlockLookback(const void* self);
+void QsciLexer_override_virtual_BlockStart(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockStart(const void* self, int* style);
+void QsciLexer_override_virtual_BlockStartKeyword(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockStartKeyword(const void* self, int* style);
+void QsciLexer_override_virtual_BraceStyle(void* self, intptr_t slot);
+int QsciLexer_virtualbase_BraceStyle(const void* self);
+void QsciLexer_override_virtual_CaseSensitive(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_CaseSensitive(const void* self);
+void QsciLexer_override_virtual_Color(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_Color(const void* self, int style);
+void QsciLexer_override_virtual_EolFill(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_EolFill(const void* self, int style);
+void QsciLexer_override_virtual_Font(void* self, intptr_t slot);
+QFont* QsciLexer_virtualbase_Font(const void* self, int style);
+void QsciLexer_override_virtual_IndentationGuideView(void* self, intptr_t slot);
+int QsciLexer_virtualbase_IndentationGuideView(const void* self);
+void QsciLexer_override_virtual_Keywords(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Keywords(const void* self, int set);
+void QsciLexer_override_virtual_DefaultStyle(void* self, intptr_t slot);
+int QsciLexer_virtualbase_DefaultStyle(const void* self);
+void QsciLexer_override_virtual_Description(void* self, intptr_t slot);
+struct miqt_string QsciLexer_virtualbase_Description(const void* self, int style);
+void QsciLexer_override_virtual_Paper(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_Paper(const void* self, int style);
+void QsciLexer_override_virtual_DefaultColorWithStyle(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_DefaultColorWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_DefaultEolFill(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_DefaultEolFill(const void* self, int style);
+void QsciLexer_override_virtual_DefaultFontWithStyle(void* self, intptr_t slot);
+QFont* QsciLexer_virtualbase_DefaultFontWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_DefaultPaperWithStyle(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_DefaultPaperWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_SetEditor(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetEditor(void* self, QsciScintilla* editor);
+void QsciLexer_override_virtual_RefreshProperties(void* self, intptr_t slot);
+void QsciLexer_virtualbase_RefreshProperties(void* self);
+void QsciLexer_override_virtual_StyleBitsNeeded(void* self, intptr_t slot);
+int QsciLexer_virtualbase_StyleBitsNeeded(const void* self);
+void QsciLexer_override_virtual_WordCharacters(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_WordCharacters(const void* self);
+void QsciLexer_override_virtual_SetAutoIndentStyle(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetAutoIndentStyle(void* self, int autoindentstyle);
+void QsciLexer_override_virtual_SetColor(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetColor(void* self, QColor* c, int style);
+void QsciLexer_override_virtual_SetEolFill(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetEolFill(void* self, bool eoffill, int style);
+void QsciLexer_override_virtual_SetFont(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetFont(void* self, QFont* f, int style);
+void QsciLexer_override_virtual_SetPaper(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetPaper(void* self, QColor* c, int style);
+void QsciLexer_override_virtual_ReadProperties(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_ReadProperties(void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexer_override_virtual_WriteProperties(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_WriteProperties(const void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexer_override_virtual_Event(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_Event(void* self, QEvent* event);
+void QsciLexer_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QsciLexer_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QsciLexer_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QsciLexer_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_CustomEvent(void* self, QEvent* event);
+void QsciLexer_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QsciLexer_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QsciLexer_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QsciLexer_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QsciLexer_Delete(QsciLexer* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla/gen_qscilexeravs.go

@@ -280,25 +280,18 @@ func miqt_exec_callback_QsciLexerAVS_SetFoldCompact(self *C.QsciLexerAVS, cb C.i
 	gofunc((&QsciLexerAVS{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerAVS) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerAVS_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerAVS) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerAVS) OnLanguage(slot func() string) {
 	C.QsciLexerAVS_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerAVS_Language
 func miqt_exec_callback_QsciLexerAVS_Language(self *C.QsciLexerAVS, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerAVS{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -721,21 +714,13 @@ func miqt_exec_callback_QsciLexerAVS_DefaultStyle(self *C.QsciLexerAVS, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerAVS) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerAVS_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerAVS) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerAVS) OnDescription(slot func(style int) string) {
 	C.QsciLexerAVS_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerAVS_Description
 func miqt_exec_callback_QsciLexerAVS_Description(self *C.QsciLexerAVS, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -743,7 +728,7 @@ func miqt_exec_callback_QsciLexerAVS_Description(self *C.QsciLexerAVS, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerAVS{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerbash.go

@@ -290,25 +290,18 @@ func miqt_exec_callback_QsciLexerBash_SetFoldCompact(self *C.QsciLexerBash, cb C
 	gofunc((&QsciLexerBash{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerBash) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerBash_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerBash) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerBash) OnLanguage(slot func() string) {
 	C.QsciLexerBash_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBash_Language
 func miqt_exec_callback_QsciLexerBash_Language(self *C.QsciLexerBash, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerBash{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -731,21 +724,13 @@ func miqt_exec_callback_QsciLexerBash_DefaultStyle(self *C.QsciLexerBash, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerBash) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerBash_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerBash) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerBash) OnDescription(slot func(style int) string) {
 	C.QsciLexerBash_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBash_Description
 func miqt_exec_callback_QsciLexerBash_Description(self *C.QsciLexerBash, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -753,7 +738,7 @@ func miqt_exec_callback_QsciLexerBash_Description(self *C.QsciLexerBash, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerBash{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerbatch.go

@@ -218,25 +218,18 @@ func QsciLexerBatch_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerBatch) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerBatch_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerBatch) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerBatch) OnLanguage(slot func() string) {
 	C.QsciLexerBatch_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBatch_Language
 func miqt_exec_callback_QsciLexerBatch_Language(self *C.QsciLexerBatch, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerBatch{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -659,21 +652,13 @@ func miqt_exec_callback_QsciLexerBatch_DefaultStyle(self *C.QsciLexerBatch, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerBatch) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerBatch_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerBatch) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerBatch) OnDescription(slot func(style int) string) {
 	C.QsciLexerBatch_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBatch_Description
 func miqt_exec_callback_QsciLexerBatch_Description(self *C.QsciLexerBatch, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -681,7 +666,7 @@ func miqt_exec_callback_QsciLexerBatch_Description(self *C.QsciLexerBatch, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerBatch{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexercmake.go

@@ -247,25 +247,18 @@ func miqt_exec_callback_QsciLexerCMake_SetFoldAtElse(self *C.QsciLexerCMake, cb
 	gofunc((&QsciLexerCMake{h: self}).callVirtualBase_SetFoldAtElse, slotval1)
 
 }
-
-func (this *QsciLexerCMake) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCMake_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCMake) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCMake) OnLanguage(slot func() string) {
 	C.QsciLexerCMake_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCMake_Language
 func miqt_exec_callback_QsciLexerCMake_Language(self *C.QsciLexerCMake, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCMake{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -688,21 +681,13 @@ func miqt_exec_callback_QsciLexerCMake_DefaultStyle(self *C.QsciLexerCMake, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCMake) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCMake_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCMake) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCMake) OnDescription(slot func(style int) string) {
 	C.QsciLexerCMake_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCMake_Description
 func miqt_exec_callback_QsciLexerCMake_Description(self *C.QsciLexerCMake, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -710,7 +695,7 @@ func miqt_exec_callback_QsciLexerCMake_Description(self *C.QsciLexerCMake, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCMake{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexercoffeescript.go

@@ -313,25 +313,18 @@ func (this *QsciLexerCoffeeScript) BlockStartKeyword1(style *int) string {
 	_ret := C.QsciLexerCoffeeScript_BlockStartKeyword1(this.h, (*C.int)(unsafe.Pointer(style)))
 	return C.GoString(_ret)
 }
-
-func (this *QsciLexerCoffeeScript) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCoffeeScript_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCoffeeScript) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCoffeeScript) OnLanguage(slot func() string) {
 	C.QsciLexerCoffeeScript_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCoffeeScript_Language
 func miqt_exec_callback_QsciLexerCoffeeScript_Language(self *C.QsciLexerCoffeeScript, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCoffeeScript{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -754,21 +747,13 @@ func miqt_exec_callback_QsciLexerCoffeeScript_DefaultStyle(self *C.QsciLexerCoff
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCoffeeScript) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCoffeeScript_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCoffeeScript) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCoffeeScript) OnDescription(slot func(style int) string) {
 	C.QsciLexerCoffeeScript_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCoffeeScript_Description
 func miqt_exec_callback_QsciLexerCoffeeScript_Description(self *C.QsciLexerCoffeeScript, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -776,7 +761,7 @@ func miqt_exec_callback_QsciLexerCoffeeScript_Description(self *C.QsciLexerCoffe
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCoffeeScript{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexercpp.go

@@ -528,25 +528,18 @@ func miqt_exec_callback_QsciLexerCPP_SetStylePreprocessor(self *C.QsciLexerCPP,
 	gofunc((&QsciLexerCPP{h: self}).callVirtualBase_SetStylePreprocessor, slotval1)
 
 }
-
-func (this *QsciLexerCPP) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCPP_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCPP) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCPP) OnLanguage(slot func() string) {
 	C.QsciLexerCPP_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCPP_Language
 func miqt_exec_callback_QsciLexerCPP_Language(self *C.QsciLexerCPP, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCPP{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -969,21 +962,13 @@ func miqt_exec_callback_QsciLexerCPP_DefaultStyle(self *C.QsciLexerCPP, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCPP) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCPP_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCPP) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCPP) OnDescription(slot func(style int) string) {
 	C.QsciLexerCPP_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCPP_Description
 func miqt_exec_callback_QsciLexerCPP_Description(self *C.QsciLexerCPP, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -991,7 +976,7 @@ func miqt_exec_callback_QsciLexerCPP_Description(self *C.QsciLexerCPP, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCPP{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexercss.go

@@ -329,25 +329,18 @@ func miqt_exec_callback_QsciLexerCSS_SetFoldCompact(self *C.QsciLexerCSS, cb C.i
 	gofunc((&QsciLexerCSS{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerCSS) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCSS_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCSS) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCSS) OnLanguage(slot func() string) {
 	C.QsciLexerCSS_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCSS_Language
 func miqt_exec_callback_QsciLexerCSS_Language(self *C.QsciLexerCSS, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCSS{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -770,21 +763,13 @@ func miqt_exec_callback_QsciLexerCSS_DefaultStyle(self *C.QsciLexerCSS, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCSS) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCSS_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCSS) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCSS) OnDescription(slot func(style int) string) {
 	C.QsciLexerCSS_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCSS_Description
 func miqt_exec_callback_QsciLexerCSS_Description(self *C.QsciLexerCSS, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -792,7 +777,7 @@ func miqt_exec_callback_QsciLexerCSS_Description(self *C.QsciLexerCSS, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCSS{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexercustom.go

@@ -11,6 +11,7 @@ import "C"
 import (
 	"github.com/mappu/miqt/qt"
 	"runtime"
+	"runtime/cgo"
 	"unsafe"
 )
 
@@ -53,6 +54,30 @@ func UnsafeNewQsciLexerCustom(h unsafe.Pointer, h_QsciLexer unsafe.Pointer, h_QO
 		QsciLexer: UnsafeNewQsciLexer(h_QsciLexer, h_QObject)}
 }
 
+// NewQsciLexerCustom constructs a new QsciLexerCustom object.
+func NewQsciLexerCustom() *QsciLexerCustom {
+	var outptr_QsciLexerCustom *C.QsciLexerCustom = nil
+	var outptr_QsciLexer *C.QsciLexer = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciLexerCustom_new(&outptr_QsciLexerCustom, &outptr_QsciLexer, &outptr_QObject)
+	ret := newQsciLexerCustom(outptr_QsciLexerCustom, outptr_QsciLexer, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
+// NewQsciLexerCustom2 constructs a new QsciLexerCustom object.
+func NewQsciLexerCustom2(parent *qt.QObject) *QsciLexerCustom {
+	var outptr_QsciLexerCustom *C.QsciLexerCustom = nil
+	var outptr_QsciLexer *C.QsciLexer = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciLexerCustom_new2((*C.QObject)(parent.UnsafePointer()), &outptr_QsciLexerCustom, &outptr_QsciLexer, &outptr_QObject)
+	ret := newQsciLexerCustom(outptr_QsciLexerCustom, outptr_QsciLexer, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QsciLexerCustom) MetaObject() *qt.QMetaObject {
 	return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QsciLexerCustom_MetaObject(this.h)))
 }
@@ -152,6 +177,895 @@ func QsciLexerCustom_TrUtf83(s string, c string, n int) string {
 func (this *QsciLexerCustom) StartStyling2(pos int, styleBits int) {
 	C.QsciLexerCustom_StartStyling2(this.h, (C.int)(pos), (C.int)(styleBits))
 }
+func (this *QsciLexerCustom) OnStyleText(slot func(start int, end int)) {
+	C.QsciLexerCustom_override_virtual_StyleText(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_StyleText
+func miqt_exec_callback_QsciLexerCustom_StyleText(self *C.QsciLexerCustom, cb C.intptr_t, start C.int, end C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(start int, end int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(start)
+
+	slotval2 := (int)(end)
+
+	gofunc(slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetEditor(editor *QsciScintilla) {
+
+	C.QsciLexerCustom_virtualbase_SetEditor(unsafe.Pointer(this.h), editor.cPointer())
+
+}
+func (this *QsciLexerCustom) OnSetEditor(slot func(super func(editor *QsciScintilla), editor *QsciScintilla)) {
+	C.QsciLexerCustom_override_virtual_SetEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetEditor
+func miqt_exec_callback_QsciLexerCustom_SetEditor(self *C.QsciLexerCustom, cb C.intptr_t, editor *C.QsciScintilla) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QsciScintilla), editor *QsciScintilla))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQsciScintilla(unsafe.Pointer(editor), nil, nil, nil, nil, nil, nil)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetEditor, slotval1)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_StyleBitsNeeded() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_StyleBitsNeeded(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnStyleBitsNeeded(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_StyleBitsNeeded(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_StyleBitsNeeded
+func miqt_exec_callback_QsciLexerCustom_StyleBitsNeeded(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_StyleBitsNeeded)
+
+	return (C.int)(virtualReturn)
+
+}
+func (this *QsciLexerCustom) OnLanguage(slot func() string) {
+	C.QsciLexerCustom_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Language
+func miqt_exec_callback_QsciLexerCustom_Language(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc()
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Lexer() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_Lexer(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnLexer(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_Lexer(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Lexer
+func miqt_exec_callback_QsciLexerCustom_Lexer(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Lexer)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_LexerId() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_LexerId(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnLexerId(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_LexerId(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_LexerId
+func miqt_exec_callback_QsciLexerCustom_LexerId(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_LexerId)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_AutoCompletionFillups() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_AutoCompletionFillups(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnAutoCompletionFillups(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_AutoCompletionFillups(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_AutoCompletionFillups
+func miqt_exec_callback_QsciLexerCustom_AutoCompletionFillups(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_AutoCompletionFillups)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_AutoCompletionWordSeparators() []string {
+
+	var _ma C.struct_miqt_array = C.QsciLexerCustom_virtualbase_AutoCompletionWordSeparators(unsafe.Pointer(this.h))
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+
+}
+func (this *QsciLexerCustom) OnAutoCompletionWordSeparators(slot func(super func() []string) []string) {
+	C.QsciLexerCustom_override_virtual_AutoCompletionWordSeparators(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_AutoCompletionWordSeparators
+func miqt_exec_callback_QsciLexerCustom_AutoCompletionWordSeparators(self *C.QsciLexerCustom, cb C.intptr_t) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_AutoCompletionWordSeparators)
+	virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_i_ms := C.struct_miqt_string{}
+		virtualReturn_i_ms.data = C.CString(virtualReturn[i])
+		virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i]))
+		defer C.free(unsafe.Pointer(virtualReturn_i_ms.data))
+		virtualReturn_CArray[i] = virtualReturn_i_ms
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockEnd(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockEnd(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockEnd(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockEnd(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockEnd
+func miqt_exec_callback_QsciLexerCustom_BlockEnd(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockEnd, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockLookback() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_BlockLookback(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnBlockLookback(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_BlockLookback(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockLookback
+func miqt_exec_callback_QsciLexerCustom_BlockLookback(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockLookback)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockStart(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockStart(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockStart(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockStart(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockStart
+func miqt_exec_callback_QsciLexerCustom_BlockStart(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockStart, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockStartKeyword(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockStartKeyword(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockStartKeyword(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockStartKeyword(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockStartKeyword
+func miqt_exec_callback_QsciLexerCustom_BlockStartKeyword(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockStartKeyword, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BraceStyle() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_BraceStyle(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnBraceStyle(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_BraceStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BraceStyle
+func miqt_exec_callback_QsciLexerCustom_BraceStyle(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BraceStyle)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_CaseSensitive() bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_CaseSensitive(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnCaseSensitive(slot func(super func() bool) bool) {
+	C.QsciLexerCustom_override_virtual_CaseSensitive(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_CaseSensitive
+func miqt_exec_callback_QsciLexerCustom_CaseSensitive(self *C.QsciLexerCustom, cb C.intptr_t) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_CaseSensitive)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Color(style int) *qt.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_Color(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnColor(slot func(super func(style int) *qt.QColor, style int) *qt.QColor) {
+	C.QsciLexerCustom_override_virtual_Color(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Color
+func miqt_exec_callback_QsciLexerCustom_Color(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QColor, style int) *qt.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Color, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_EolFill(style int) bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_EolFill(unsafe.Pointer(this.h), (C.int)(style)))
+
+}
+func (this *QsciLexerCustom) OnEolFill(slot func(super func(style int) bool, style int) bool) {
+	C.QsciLexerCustom_override_virtual_EolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_EolFill
+func miqt_exec_callback_QsciLexerCustom_EolFill(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) bool, style int) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_EolFill, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Font(style int) *qt.QFont {
+
+	_ret := C.QsciLexerCustom_virtualbase_Font(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQFont(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnFont(slot func(super func(style int) *qt.QFont, style int) *qt.QFont) {
+	C.QsciLexerCustom_override_virtual_Font(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Font
+func miqt_exec_callback_QsciLexerCustom_Font(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QFont {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QFont, style int) *qt.QFont)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Font, slotval1)
+
+	return (*C.QFont)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_IndentationGuideView() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_IndentationGuideView(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnIndentationGuideView(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_IndentationGuideView(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_IndentationGuideView
+func miqt_exec_callback_QsciLexerCustom_IndentationGuideView(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_IndentationGuideView)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Keywords(set int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_Keywords(unsafe.Pointer(this.h), (C.int)(set))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnKeywords(slot func(super func(set int) string, set int) string) {
+	C.QsciLexerCustom_override_virtual_Keywords(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Keywords
+func miqt_exec_callback_QsciLexerCustom_Keywords(self *C.QsciLexerCustom, cb C.intptr_t, set C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(set int) string, set int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(set)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Keywords, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultStyle() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_DefaultStyle(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnDefaultStyle(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_DefaultStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultStyle(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultStyle)
+
+	return (C.int)(virtualReturn)
+
+}
+func (this *QsciLexerCustom) OnDescription(slot func(style int) string) {
+	C.QsciLexerCustom_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Description
+func miqt_exec_callback_QsciLexerCustom_Description(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.struct_miqt_string {
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc(slotval1)
+	virtualReturn_ms := C.struct_miqt_string{}
+	virtualReturn_ms.data = C.CString(virtualReturn)
+	virtualReturn_ms.len = C.size_t(len(virtualReturn))
+	defer C.free(unsafe.Pointer(virtualReturn_ms.data))
+
+	return virtualReturn_ms
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Paper(style int) *qt.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_Paper(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnPaper(slot func(super func(style int) *qt.QColor, style int) *qt.QColor) {
+	C.QsciLexerCustom_override_virtual_Paper(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Paper
+func miqt_exec_callback_QsciLexerCustom_Paper(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QColor, style int) *qt.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Paper, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultColorWithStyle(style int) *qt.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultColorWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultColorWithStyle(slot func(super func(style int) *qt.QColor, style int) *qt.QColor) {
+	C.QsciLexerCustom_override_virtual_DefaultColorWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultColorWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultColorWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QColor, style int) *qt.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultColorWithStyle, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultEolFill(style int) bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_DefaultEolFill(unsafe.Pointer(this.h), (C.int)(style)))
+
+}
+func (this *QsciLexerCustom) OnDefaultEolFill(slot func(super func(style int) bool, style int) bool) {
+	C.QsciLexerCustom_override_virtual_DefaultEolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultEolFill
+func miqt_exec_callback_QsciLexerCustom_DefaultEolFill(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) bool, style int) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultEolFill, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultFontWithStyle(style int) *qt.QFont {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultFontWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQFont(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultFontWithStyle(slot func(super func(style int) *qt.QFont, style int) *qt.QFont) {
+	C.QsciLexerCustom_override_virtual_DefaultFontWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultFontWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultFontWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QFont {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QFont, style int) *qt.QFont)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultFontWithStyle, slotval1)
+
+	return (*C.QFont)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultPaperWithStyle(style int) *qt.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultPaperWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultPaperWithStyle(slot func(super func(style int) *qt.QColor, style int) *qt.QColor) {
+	C.QsciLexerCustom_override_virtual_DefaultPaperWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultPaperWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultPaperWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt.QColor, style int) *qt.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultPaperWithStyle, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_RefreshProperties() {
+
+	C.QsciLexerCustom_virtualbase_RefreshProperties(unsafe.Pointer(this.h))
+
+}
+func (this *QsciLexerCustom) OnRefreshProperties(slot func(super func())) {
+	C.QsciLexerCustom_override_virtual_RefreshProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_RefreshProperties
+func miqt_exec_callback_QsciLexerCustom_RefreshProperties(self *C.QsciLexerCustom, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_RefreshProperties)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_WordCharacters() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_WordCharacters(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnWordCharacters(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_WordCharacters(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_WordCharacters
+func miqt_exec_callback_QsciLexerCustom_WordCharacters(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_WordCharacters)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetAutoIndentStyle(autoindentstyle int) {
+
+	C.QsciLexerCustom_virtualbase_SetAutoIndentStyle(unsafe.Pointer(this.h), (C.int)(autoindentstyle))
+
+}
+func (this *QsciLexerCustom) OnSetAutoIndentStyle(slot func(super func(autoindentstyle int), autoindentstyle int)) {
+	C.QsciLexerCustom_override_virtual_SetAutoIndentStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetAutoIndentStyle
+func miqt_exec_callback_QsciLexerCustom_SetAutoIndentStyle(self *C.QsciLexerCustom, cb C.intptr_t, autoindentstyle C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(autoindentstyle int), autoindentstyle int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(autoindentstyle)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetAutoIndentStyle, slotval1)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetColor(c *qt.QColor, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetColor(unsafe.Pointer(this.h), (*C.QColor)(c.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetColor(slot func(super func(c *qt.QColor, style int), c *qt.QColor, style int)) {
+	C.QsciLexerCustom_override_virtual_SetColor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetColor
+func miqt_exec_callback_QsciLexerCustom_SetColor(self *C.QsciLexerCustom, cb C.intptr_t, c *C.QColor, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(c *qt.QColor, style int), c *qt.QColor, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQColor(unsafe.Pointer(c))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetColor, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetEolFill(eoffill bool, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetEolFill(unsafe.Pointer(this.h), (C.bool)(eoffill), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetEolFill(slot func(super func(eoffill bool, style int), eoffill bool, style int)) {
+	C.QsciLexerCustom_override_virtual_SetEolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetEolFill
+func miqt_exec_callback_QsciLexerCustom_SetEolFill(self *C.QsciLexerCustom, cb C.intptr_t, eoffill C.bool, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(eoffill bool, style int), eoffill bool, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(eoffill)
+
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetEolFill, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetFont(f *qt.QFont, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetFont(unsafe.Pointer(this.h), (*C.QFont)(f.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetFont(slot func(super func(f *qt.QFont, style int), f *qt.QFont, style int)) {
+	C.QsciLexerCustom_override_virtual_SetFont(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetFont
+func miqt_exec_callback_QsciLexerCustom_SetFont(self *C.QsciLexerCustom, cb C.intptr_t, f *C.QFont, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(f *qt.QFont, style int), f *qt.QFont, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQFont(unsafe.Pointer(f))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetFont, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetPaper(c *qt.QColor, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetPaper(unsafe.Pointer(this.h), (*C.QColor)(c.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetPaper(slot func(super func(c *qt.QColor, style int), c *qt.QColor, style int)) {
+	C.QsciLexerCustom_override_virtual_SetPaper(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetPaper
+func miqt_exec_callback_QsciLexerCustom_SetPaper(self *C.QsciLexerCustom, cb C.intptr_t, c *C.QColor, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(c *qt.QColor, style int), c *qt.QColor, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQColor(unsafe.Pointer(c))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetPaper, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_ReadProperties(qs *qt.QSettings, prefix string) bool {
+	prefix_ms := C.struct_miqt_string{}
+	prefix_ms.data = C.CString(prefix)
+	prefix_ms.len = C.size_t(len(prefix))
+	defer C.free(unsafe.Pointer(prefix_ms.data))
+
+	return (bool)(C.QsciLexerCustom_virtualbase_ReadProperties(unsafe.Pointer(this.h), (*C.QSettings)(qs.UnsafePointer()), prefix_ms))
+
+}
+func (this *QsciLexerCustom) OnReadProperties(slot func(super func(qs *qt.QSettings, prefix string) bool, qs *qt.QSettings, prefix string) bool) {
+	C.QsciLexerCustom_override_virtual_ReadProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_ReadProperties
+func miqt_exec_callback_QsciLexerCustom_ReadProperties(self *C.QsciLexerCustom, cb C.intptr_t, qs *C.QSettings, prefix C.struct_miqt_string) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(qs *qt.QSettings, prefix string) bool, qs *qt.QSettings, prefix string) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQSettings(unsafe.Pointer(qs), nil)
+	var prefix_ms C.struct_miqt_string = prefix
+	prefix_ret := C.GoStringN(prefix_ms.data, C.int(int64(prefix_ms.len)))
+	C.free(unsafe.Pointer(prefix_ms.data))
+	slotval2 := prefix_ret
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_ReadProperties, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_WriteProperties(qs *qt.QSettings, prefix string) bool {
+	prefix_ms := C.struct_miqt_string{}
+	prefix_ms.data = C.CString(prefix)
+	prefix_ms.len = C.size_t(len(prefix))
+	defer C.free(unsafe.Pointer(prefix_ms.data))
+
+	return (bool)(C.QsciLexerCustom_virtualbase_WriteProperties(unsafe.Pointer(this.h), (*C.QSettings)(qs.UnsafePointer()), prefix_ms))
+
+}
+func (this *QsciLexerCustom) OnWriteProperties(slot func(super func(qs *qt.QSettings, prefix string) bool, qs *qt.QSettings, prefix string) bool) {
+	C.QsciLexerCustom_override_virtual_WriteProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_WriteProperties
+func miqt_exec_callback_QsciLexerCustom_WriteProperties(self *C.QsciLexerCustom, cb C.intptr_t, qs *C.QSettings, prefix C.struct_miqt_string) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(qs *qt.QSettings, prefix string) bool, qs *qt.QSettings, prefix string) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQSettings(unsafe.Pointer(qs), nil)
+	var prefix_ms C.struct_miqt_string = prefix
+	prefix_ret := C.GoStringN(prefix_ms.data, C.int(int64(prefix_ms.len)))
+	C.free(unsafe.Pointer(prefix_ms.data))
+	slotval2 := prefix_ret
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_WriteProperties, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QsciLexerCustom) Delete() {

qt-restricted-extras/qscintilla/gen_qscilexercustom.h

@@ -15,21 +15,29 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QColor;
+class QFont;
 class QMetaObject;
 class QObject;
+class QSettings;
 class QsciLexer;
 class QsciLexerCustom;
 class QsciScintilla;
 class QsciStyle;
 #else
+typedef struct QColor QColor;
+typedef struct QFont QFont;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
+typedef struct QSettings QSettings;
 typedef struct QsciLexer QsciLexer;
 typedef struct QsciLexerCustom QsciLexerCustom;
 typedef struct QsciScintilla QsciScintilla;
 typedef struct QsciStyle QsciStyle;
 #endif
 
+void QsciLexerCustom_new(QsciLexerCustom** outptr_QsciLexerCustom, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
+void QsciLexerCustom_new2(QObject* parent, QsciLexerCustom** outptr_QsciLexerCustom, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
 QMetaObject* QsciLexerCustom_MetaObject(const QsciLexerCustom* self);
 void* QsciLexerCustom_Metacast(QsciLexerCustom* self, const char* param1);
 struct miqt_string QsciLexerCustom_Tr(const char* s);
@@ -45,6 +53,76 @@ struct miqt_string QsciLexerCustom_Tr3(const char* s, const char* c, int n);
 struct miqt_string QsciLexerCustom_TrUtf82(const char* s, const char* c);
 struct miqt_string QsciLexerCustom_TrUtf83(const char* s, const char* c, int n);
 void QsciLexerCustom_StartStyling2(QsciLexerCustom* self, int pos, int styleBits);
+void QsciLexerCustom_override_virtual_StyleText(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_StyleText(void* self, int start, int end);
+void QsciLexerCustom_override_virtual_SetEditor(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetEditor(void* self, QsciScintilla* editor);
+void QsciLexerCustom_override_virtual_StyleBitsNeeded(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_StyleBitsNeeded(const void* self);
+void QsciLexerCustom_override_virtual_Language(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Language(const void* self);
+void QsciLexerCustom_override_virtual_Lexer(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Lexer(const void* self);
+void QsciLexerCustom_override_virtual_LexerId(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_LexerId(const void* self);
+void QsciLexerCustom_override_virtual_AutoCompletionFillups(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_AutoCompletionFillups(const void* self);
+void QsciLexerCustom_override_virtual_AutoCompletionWordSeparators(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciLexerCustom_virtualbase_AutoCompletionWordSeparators(const void* self);
+void QsciLexerCustom_override_virtual_BlockEnd(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockEnd(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BlockLookback(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_BlockLookback(const void* self);
+void QsciLexerCustom_override_virtual_BlockStart(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockStart(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BlockStartKeyword(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockStartKeyword(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BraceStyle(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_BraceStyle(const void* self);
+void QsciLexerCustom_override_virtual_CaseSensitive(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_CaseSensitive(const void* self);
+void QsciLexerCustom_override_virtual_Color(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_Color(const void* self, int style);
+void QsciLexerCustom_override_virtual_EolFill(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_EolFill(const void* self, int style);
+void QsciLexerCustom_override_virtual_Font(void* self, intptr_t slot);
+QFont* QsciLexerCustom_virtualbase_Font(const void* self, int style);
+void QsciLexerCustom_override_virtual_IndentationGuideView(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_IndentationGuideView(const void* self);
+void QsciLexerCustom_override_virtual_Keywords(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Keywords(const void* self, int set);
+void QsciLexerCustom_override_virtual_DefaultStyle(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_DefaultStyle(const void* self);
+void QsciLexerCustom_override_virtual_Description(void* self, intptr_t slot);
+struct miqt_string QsciLexerCustom_virtualbase_Description(const void* self, int style);
+void QsciLexerCustom_override_virtual_Paper(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_Paper(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultColorWithStyle(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_DefaultColorWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultEolFill(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_DefaultEolFill(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultFontWithStyle(void* self, intptr_t slot);
+QFont* QsciLexerCustom_virtualbase_DefaultFontWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultPaperWithStyle(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_DefaultPaperWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_RefreshProperties(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_RefreshProperties(void* self);
+void QsciLexerCustom_override_virtual_WordCharacters(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_WordCharacters(const void* self);
+void QsciLexerCustom_override_virtual_SetAutoIndentStyle(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetAutoIndentStyle(void* self, int autoindentstyle);
+void QsciLexerCustom_override_virtual_SetColor(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetColor(void* self, QColor* c, int style);
+void QsciLexerCustom_override_virtual_SetEolFill(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetEolFill(void* self, bool eoffill, int style);
+void QsciLexerCustom_override_virtual_SetFont(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetFont(void* self, QFont* f, int style);
+void QsciLexerCustom_override_virtual_SetPaper(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetPaper(void* self, QColor* c, int style);
+void QsciLexerCustom_override_virtual_ReadProperties(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_ReadProperties(void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexerCustom_override_virtual_WriteProperties(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_WriteProperties(const void* self, QSettings* qs, struct miqt_string prefix);
 void QsciLexerCustom_Delete(QsciLexerCustom* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla/gen_qscilexerd.go

@@ -373,25 +373,18 @@ func miqt_exec_callback_QsciLexerD_SetFoldCompact(self *C.QsciLexerD, cb C.intpt
 	gofunc((&QsciLexerD{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerD) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerD_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerD) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerD) OnLanguage(slot func() string) {
 	C.QsciLexerD_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerD_Language
 func miqt_exec_callback_QsciLexerD_Language(self *C.QsciLexerD, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerD{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -814,21 +807,13 @@ func miqt_exec_callback_QsciLexerD_DefaultStyle(self *C.QsciLexerD, cb C.intptr_
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerD) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerD_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerD) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerD) OnDescription(slot func(style int) string) {
 	C.QsciLexerD_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerD_Description
 func miqt_exec_callback_QsciLexerD_Description(self *C.QsciLexerD, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -836,7 +821,7 @@ func miqt_exec_callback_QsciLexerD_Description(self *C.QsciLexerD, cb C.intptr_t
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerD{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerdiff.go

@@ -195,25 +195,18 @@ func QsciLexerDiff_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerDiff) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerDiff_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerDiff) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerDiff) OnLanguage(slot func() string) {
 	C.QsciLexerDiff_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerDiff_Language
 func miqt_exec_callback_QsciLexerDiff_Language(self *C.QsciLexerDiff, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerDiff{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -636,21 +629,13 @@ func miqt_exec_callback_QsciLexerDiff_DefaultStyle(self *C.QsciLexerDiff, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerDiff) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerDiff_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerDiff) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerDiff) OnDescription(slot func(style int) string) {
 	C.QsciLexerDiff_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerDiff_Description
 func miqt_exec_callback_QsciLexerDiff_Description(self *C.QsciLexerDiff, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -658,7 +643,7 @@ func miqt_exec_callback_QsciLexerDiff_Description(self *C.QsciLexerDiff, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerDiff{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexeredifact.go

@@ -187,25 +187,18 @@ func QsciLexerEDIFACT_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerEDIFACT) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerEDIFACT_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerEDIFACT) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerEDIFACT) OnLanguage(slot func() string) {
 	C.QsciLexerEDIFACT_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerEDIFACT_Language
 func miqt_exec_callback_QsciLexerEDIFACT_Language(self *C.QsciLexerEDIFACT, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerEDIFACT{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -628,21 +621,13 @@ func miqt_exec_callback_QsciLexerEDIFACT_DefaultStyle(self *C.QsciLexerEDIFACT,
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerEDIFACT) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerEDIFACT_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerEDIFACT) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerEDIFACT) OnDescription(slot func(style int) string) {
 	C.QsciLexerEDIFACT_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerEDIFACT_Description
 func miqt_exec_callback_QsciLexerEDIFACT_Description(self *C.QsciLexerEDIFACT, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -650,7 +635,7 @@ func miqt_exec_callback_QsciLexerEDIFACT_Description(self *C.QsciLexerEDIFACT, c
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerEDIFACT{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerfortran77.go

@@ -255,25 +255,18 @@ func miqt_exec_callback_QsciLexerFortran77_SetFoldCompact(self *C.QsciLexerFortr
 	gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerFortran77) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerFortran77_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerFortran77) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerFortran77) OnLanguage(slot func() string) {
 	C.QsciLexerFortran77_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerFortran77_Language
 func miqt_exec_callback_QsciLexerFortran77_Language(self *C.QsciLexerFortran77, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -696,21 +689,13 @@ func miqt_exec_callback_QsciLexerFortran77_DefaultStyle(self *C.QsciLexerFortran
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerFortran77) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerFortran77_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerFortran77) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerFortran77) OnDescription(slot func(style int) string) {
 	C.QsciLexerFortran77_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerFortran77_Description
 func miqt_exec_callback_QsciLexerFortran77_Description(self *C.QsciLexerFortran77, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -718,7 +703,7 @@ func miqt_exec_callback_QsciLexerFortran77_Description(self *C.QsciLexerFortran7
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerhtml.go

@@ -450,25 +450,18 @@ func miqt_exec_callback_QsciLexerHTML_SetCaseSensitiveTags(self *C.QsciLexerHTML
 	gofunc((&QsciLexerHTML{h: self}).callVirtualBase_SetCaseSensitiveTags, slotval1)
 
 }
-
-func (this *QsciLexerHTML) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerHTML_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerHTML) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerHTML) OnLanguage(slot func() string) {
 	C.QsciLexerHTML_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerHTML_Language
 func miqt_exec_callback_QsciLexerHTML_Language(self *C.QsciLexerHTML, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerHTML{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -891,21 +884,13 @@ func miqt_exec_callback_QsciLexerHTML_DefaultStyle(self *C.QsciLexerHTML, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerHTML) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerHTML_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerHTML) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerHTML) OnDescription(slot func(style int) string) {
 	C.QsciLexerHTML_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerHTML_Description
 func miqt_exec_callback_QsciLexerHTML_Description(self *C.QsciLexerHTML, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -913,7 +898,7 @@ func miqt_exec_callback_QsciLexerHTML_Description(self *C.QsciLexerHTML, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerHTML{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerjson.go

@@ -243,25 +243,18 @@ func QsciLexerJSON_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerJSON) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerJSON_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerJSON) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerJSON) OnLanguage(slot func() string) {
 	C.QsciLexerJSON_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerJSON_Language
 func miqt_exec_callback_QsciLexerJSON_Language(self *C.QsciLexerJSON, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerJSON{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -684,21 +677,13 @@ func miqt_exec_callback_QsciLexerJSON_DefaultStyle(self *C.QsciLexerJSON, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerJSON) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerJSON_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerJSON) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerJSON) OnDescription(slot func(style int) string) {
 	C.QsciLexerJSON_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerJSON_Description
 func miqt_exec_callback_QsciLexerJSON_Description(self *C.QsciLexerJSON, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -706,7 +691,7 @@ func miqt_exec_callback_QsciLexerJSON_Description(self *C.QsciLexerJSON, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerJSON{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerlua.go

@@ -283,25 +283,18 @@ func miqt_exec_callback_QsciLexerLua_SetFoldCompact(self *C.QsciLexerLua, cb C.i
 	gofunc((&QsciLexerLua{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerLua) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerLua_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerLua) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerLua) OnLanguage(slot func() string) {
 	C.QsciLexerLua_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerLua_Language
 func miqt_exec_callback_QsciLexerLua_Language(self *C.QsciLexerLua, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerLua{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -724,21 +717,13 @@ func miqt_exec_callback_QsciLexerLua_DefaultStyle(self *C.QsciLexerLua, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerLua) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerLua_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerLua) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerLua) OnDescription(slot func(style int) string) {
 	C.QsciLexerLua_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerLua_Description
 func miqt_exec_callback_QsciLexerLua_Description(self *C.QsciLexerLua, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -746,7 +731,7 @@ func miqt_exec_callback_QsciLexerLua_Description(self *C.QsciLexerLua, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerLua{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexermakefile.go

@@ -208,25 +208,18 @@ func QsciLexerMakefile_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMakefile) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMakefile_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMakefile) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMakefile) OnLanguage(slot func() string) {
 	C.QsciLexerMakefile_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMakefile_Language
 func miqt_exec_callback_QsciLexerMakefile_Language(self *C.QsciLexerMakefile, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMakefile{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -649,21 +642,13 @@ func miqt_exec_callback_QsciLexerMakefile_DefaultStyle(self *C.QsciLexerMakefile
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMakefile) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMakefile_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMakefile) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMakefile) OnDescription(slot func(style int) string) {
 	C.QsciLexerMakefile_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMakefile_Description
 func miqt_exec_callback_QsciLexerMakefile_Description(self *C.QsciLexerMakefile, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -671,7 +656,7 @@ func miqt_exec_callback_QsciLexerMakefile_Description(self *C.QsciLexerMakefile,
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMakefile{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexermarkdown.go

@@ -214,25 +214,18 @@ func QsciLexerMarkdown_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMarkdown) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMarkdown_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMarkdown) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMarkdown) OnLanguage(slot func() string) {
 	C.QsciLexerMarkdown_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMarkdown_Language
 func miqt_exec_callback_QsciLexerMarkdown_Language(self *C.QsciLexerMarkdown, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMarkdown{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -655,21 +648,13 @@ func miqt_exec_callback_QsciLexerMarkdown_DefaultStyle(self *C.QsciLexerMarkdown
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMarkdown) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMarkdown_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMarkdown) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMarkdown) OnDescription(slot func(style int) string) {
 	C.QsciLexerMarkdown_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMarkdown_Description
 func miqt_exec_callback_QsciLexerMarkdown_Description(self *C.QsciLexerMarkdown, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -677,7 +662,7 @@ func miqt_exec_callback_QsciLexerMarkdown_Description(self *C.QsciLexerMarkdown,
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMarkdown{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexermatlab.go

@@ -199,25 +199,18 @@ func QsciLexerMatlab_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMatlab) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMatlab_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMatlab) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMatlab) OnLanguage(slot func() string) {
 	C.QsciLexerMatlab_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMatlab_Language
 func miqt_exec_callback_QsciLexerMatlab_Language(self *C.QsciLexerMatlab, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMatlab{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -640,21 +633,13 @@ func miqt_exec_callback_QsciLexerMatlab_DefaultStyle(self *C.QsciLexerMatlab, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMatlab) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMatlab_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMatlab) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMatlab) OnDescription(slot func(style int) string) {
 	C.QsciLexerMatlab_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMatlab_Description
 func miqt_exec_callback_QsciLexerMatlab_Description(self *C.QsciLexerMatlab, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -662,7 +647,7 @@ func miqt_exec_callback_QsciLexerMatlab_Description(self *C.QsciLexerMatlab, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMatlab{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerpascal.go

@@ -368,25 +368,18 @@ func miqt_exec_callback_QsciLexerPascal_SetFoldPreprocessor(self *C.QsciLexerPas
 	gofunc((&QsciLexerPascal{h: self}).callVirtualBase_SetFoldPreprocessor, slotval1)
 
 }
-
-func (this *QsciLexerPascal) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPascal_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPascal) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPascal) OnLanguage(slot func() string) {
 	C.QsciLexerPascal_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPascal_Language
 func miqt_exec_callback_QsciLexerPascal_Language(self *C.QsciLexerPascal, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPascal{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -809,21 +802,13 @@ func miqt_exec_callback_QsciLexerPascal_DefaultStyle(self *C.QsciLexerPascal, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPascal) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPascal_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPascal) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPascal) OnDescription(slot func(style int) string) {
 	C.QsciLexerPascal_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPascal_Description
 func miqt_exec_callback_QsciLexerPascal_Description(self *C.QsciLexerPascal, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -831,7 +816,7 @@ func miqt_exec_callback_QsciLexerPascal_Description(self *C.QsciLexerPascal, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPascal{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerperl.go

@@ -374,25 +374,18 @@ func miqt_exec_callback_QsciLexerPerl_SetFoldCompact(self *C.QsciLexerPerl, cb C
 	gofunc((&QsciLexerPerl{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerPerl) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPerl_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPerl) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPerl) OnLanguage(slot func() string) {
 	C.QsciLexerPerl_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPerl_Language
 func miqt_exec_callback_QsciLexerPerl_Language(self *C.QsciLexerPerl, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPerl{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -815,21 +808,13 @@ func miqt_exec_callback_QsciLexerPerl_DefaultStyle(self *C.QsciLexerPerl, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPerl) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPerl_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPerl) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPerl) OnDescription(slot func(style int) string) {
 	C.QsciLexerPerl_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPerl_Description
 func miqt_exec_callback_QsciLexerPerl_Description(self *C.QsciLexerPerl, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -837,7 +822,7 @@ func miqt_exec_callback_QsciLexerPerl_Description(self *C.QsciLexerPerl, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPerl{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerpo.go

@@ -266,25 +266,18 @@ func miqt_exec_callback_QsciLexerPO_SetFoldCompact(self *C.QsciLexerPO, cb C.int
 	gofunc((&QsciLexerPO{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerPO) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPO_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPO) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPO) OnLanguage(slot func() string) {
 	C.QsciLexerPO_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPO_Language
 func miqt_exec_callback_QsciLexerPO_Language(self *C.QsciLexerPO, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPO{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -707,21 +700,13 @@ func miqt_exec_callback_QsciLexerPO_DefaultStyle(self *C.QsciLexerPO, cb C.intpt
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPO) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPO_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPO) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPO) OnDescription(slot func(style int) string) {
 	C.QsciLexerPO_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPO_Description
 func miqt_exec_callback_QsciLexerPO_Description(self *C.QsciLexerPO, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -729,7 +714,7 @@ func miqt_exec_callback_QsciLexerPO_Description(self *C.QsciLexerPO, cb C.intptr
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPO{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerpostscript.go

@@ -345,25 +345,18 @@ func miqt_exec_callback_QsciLexerPostScript_SetFoldAtElse(self *C.QsciLexerPostS
 	gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_SetFoldAtElse, slotval1)
 
 }
-
-func (this *QsciLexerPostScript) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPostScript_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPostScript) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPostScript) OnLanguage(slot func() string) {
 	C.QsciLexerPostScript_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPostScript_Language
 func miqt_exec_callback_QsciLexerPostScript_Language(self *C.QsciLexerPostScript, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -786,21 +779,13 @@ func miqt_exec_callback_QsciLexerPostScript_DefaultStyle(self *C.QsciLexerPostSc
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPostScript) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPostScript_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPostScript) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPostScript) OnDescription(slot func(style int) string) {
 	C.QsciLexerPostScript_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPostScript_Description
 func miqt_exec_callback_QsciLexerPostScript_Description(self *C.QsciLexerPostScript, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -808,7 +793,7 @@ func miqt_exec_callback_QsciLexerPostScript_Description(self *C.QsciLexerPostScr
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerpov.go

@@ -324,25 +324,18 @@ func miqt_exec_callback_QsciLexerPOV_SetFoldDirectives(self *C.QsciLexerPOV, cb
 	gofunc((&QsciLexerPOV{h: self}).callVirtualBase_SetFoldDirectives, slotval1)
 
 }
-
-func (this *QsciLexerPOV) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPOV_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPOV) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPOV) OnLanguage(slot func() string) {
 	C.QsciLexerPOV_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPOV_Language
 func miqt_exec_callback_QsciLexerPOV_Language(self *C.QsciLexerPOV, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPOV{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -765,21 +758,13 @@ func miqt_exec_callback_QsciLexerPOV_DefaultStyle(self *C.QsciLexerPOV, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPOV) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPOV_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPOV) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPOV) OnDescription(slot func(style int) string) {
 	C.QsciLexerPOV_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPOV_Description
 func miqt_exec_callback_QsciLexerPOV_Description(self *C.QsciLexerPOV, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -787,7 +772,7 @@ func miqt_exec_callback_QsciLexerPOV_Description(self *C.QsciLexerPOV, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPOV{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerproperties.go

@@ -250,25 +250,18 @@ func miqt_exec_callback_QsciLexerProperties_SetFoldCompact(self *C.QsciLexerProp
 	gofunc((&QsciLexerProperties{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerProperties) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerProperties_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerProperties) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerProperties) OnLanguage(slot func() string) {
 	C.QsciLexerProperties_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerProperties_Language
 func miqt_exec_callback_QsciLexerProperties_Language(self *C.QsciLexerProperties, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerProperties{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -691,21 +684,13 @@ func miqt_exec_callback_QsciLexerProperties_DefaultStyle(self *C.QsciLexerProper
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerProperties) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerProperties_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerProperties) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerProperties) OnDescription(slot func(style int) string) {
 	C.QsciLexerProperties_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerProperties_Description
 func miqt_exec_callback_QsciLexerProperties_Description(self *C.QsciLexerProperties, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -713,7 +698,7 @@ func miqt_exec_callback_QsciLexerProperties_Description(self *C.QsciLexerPropert
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerProperties{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerpython.go

@@ -433,25 +433,18 @@ func miqt_exec_callback_QsciLexerPython_SetIndentationWarning(self *C.QsciLexerP
 	gofunc((&QsciLexerPython{h: self}).callVirtualBase_SetIndentationWarning, slotval1)
 
 }
-
-func (this *QsciLexerPython) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPython_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPython) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPython) OnLanguage(slot func() string) {
 	C.QsciLexerPython_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPython_Language
 func miqt_exec_callback_QsciLexerPython_Language(self *C.QsciLexerPython, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPython{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -852,21 +845,13 @@ func miqt_exec_callback_QsciLexerPython_DefaultStyle(self *C.QsciLexerPython, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPython) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPython_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPython) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPython) OnDescription(slot func(style int) string) {
 	C.QsciLexerPython_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPython_Description
 func miqt_exec_callback_QsciLexerPython_Description(self *C.QsciLexerPython, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -874,7 +859,7 @@ func miqt_exec_callback_QsciLexerPython_Description(self *C.QsciLexerPython, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPython{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerruby.go

@@ -286,25 +286,18 @@ func (this *QsciLexerRuby) BlockStartKeyword1(style *int) string {
 	_ret := C.QsciLexerRuby_BlockStartKeyword1(this.h, (*C.int)(unsafe.Pointer(style)))
 	return C.GoString(_ret)
 }
-
-func (this *QsciLexerRuby) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerRuby_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerRuby) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerRuby) OnLanguage(slot func() string) {
 	C.QsciLexerRuby_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerRuby_Language
 func miqt_exec_callback_QsciLexerRuby_Language(self *C.QsciLexerRuby, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerRuby{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -727,21 +720,13 @@ func miqt_exec_callback_QsciLexerRuby_DefaultStyle(self *C.QsciLexerRuby, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerRuby) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerRuby_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerRuby) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerRuby) OnDescription(slot func(style int) string) {
 	C.QsciLexerRuby_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerRuby_Description
 func miqt_exec_callback_QsciLexerRuby_Description(self *C.QsciLexerRuby, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -749,7 +734,7 @@ func miqt_exec_callback_QsciLexerRuby_Description(self *C.QsciLexerRuby, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerRuby{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerspice.go

@@ -203,25 +203,18 @@ func QsciLexerSpice_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerSpice) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerSpice_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerSpice) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerSpice) OnLanguage(slot func() string) {
 	C.QsciLexerSpice_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSpice_Language
 func miqt_exec_callback_QsciLexerSpice_Language(self *C.QsciLexerSpice, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerSpice{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -644,21 +637,13 @@ func miqt_exec_callback_QsciLexerSpice_DefaultStyle(self *C.QsciLexerSpice, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerSpice) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerSpice_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerSpice) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerSpice) OnDescription(slot func(style int) string) {
 	C.QsciLexerSpice_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSpice_Description
 func miqt_exec_callback_QsciLexerSpice_Description(self *C.QsciLexerSpice, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -666,7 +651,7 @@ func miqt_exec_callback_QsciLexerSpice_Description(self *C.QsciLexerSpice, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerSpice{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexersql.go

@@ -364,25 +364,18 @@ func miqt_exec_callback_QsciLexerSQL_SetFoldCompact(self *C.QsciLexerSQL, cb C.i
 	gofunc((&QsciLexerSQL{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerSQL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerSQL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerSQL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerSQL) OnLanguage(slot func() string) {
 	C.QsciLexerSQL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSQL_Language
 func miqt_exec_callback_QsciLexerSQL_Language(self *C.QsciLexerSQL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerSQL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -805,21 +798,13 @@ func miqt_exec_callback_QsciLexerSQL_DefaultStyle(self *C.QsciLexerSQL, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerSQL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerSQL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerSQL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerSQL) OnDescription(slot func(style int) string) {
 	C.QsciLexerSQL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSQL_Description
 func miqt_exec_callback_QsciLexerSQL_Description(self *C.QsciLexerSQL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -827,7 +812,7 @@ func miqt_exec_callback_QsciLexerSQL_Description(self *C.QsciLexerSQL, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerSQL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexertcl.go

@@ -239,25 +239,18 @@ func QsciLexerTCL_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerTCL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerTCL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerTCL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerTCL) OnLanguage(slot func() string) {
 	C.QsciLexerTCL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTCL_Language
 func miqt_exec_callback_QsciLexerTCL_Language(self *C.QsciLexerTCL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerTCL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -680,21 +673,13 @@ func miqt_exec_callback_QsciLexerTCL_DefaultStyle(self *C.QsciLexerTCL, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerTCL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerTCL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerTCL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerTCL) OnDescription(slot func(style int) string) {
 	C.QsciLexerTCL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTCL_Description
 func miqt_exec_callback_QsciLexerTCL_Description(self *C.QsciLexerTCL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -702,7 +687,7 @@ func miqt_exec_callback_QsciLexerTCL_Description(self *C.QsciLexerTCL, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerTCL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexertex.go

@@ -230,25 +230,18 @@ func QsciLexerTeX_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerTeX) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerTeX_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerTeX) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerTeX) OnLanguage(slot func() string) {
 	C.QsciLexerTeX_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTeX_Language
 func miqt_exec_callback_QsciLexerTeX_Language(self *C.QsciLexerTeX, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerTeX{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -671,21 +664,13 @@ func miqt_exec_callback_QsciLexerTeX_DefaultStyle(self *C.QsciLexerTeX, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerTeX) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerTeX_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerTeX) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerTeX) OnDescription(slot func(style int) string) {
 	C.QsciLexerTeX_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTeX_Description
 func miqt_exec_callback_QsciLexerTeX_Description(self *C.QsciLexerTeX, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -693,7 +678,7 @@ func miqt_exec_callback_QsciLexerTeX_Description(self *C.QsciLexerTeX, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerTeX{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexerverilog.go

@@ -292,25 +292,18 @@ func QsciLexerVerilog_TrUtf83(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerVerilog) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerVerilog_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerVerilog) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerVerilog) OnLanguage(slot func() string) {
 	C.QsciLexerVerilog_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVerilog_Language
 func miqt_exec_callback_QsciLexerVerilog_Language(self *C.QsciLexerVerilog, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerVerilog{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -733,21 +726,13 @@ func miqt_exec_callback_QsciLexerVerilog_DefaultStyle(self *C.QsciLexerVerilog,
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerVerilog) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerVerilog_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerVerilog) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerVerilog) OnDescription(slot func(style int) string) {
 	C.QsciLexerVerilog_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVerilog_Description
 func miqt_exec_callback_QsciLexerVerilog_Description(self *C.QsciLexerVerilog, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -755,7 +740,7 @@ func miqt_exec_callback_QsciLexerVerilog_Description(self *C.QsciLexerVerilog, c
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerVerilog{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexervhdl.go

@@ -380,25 +380,18 @@ func miqt_exec_callback_QsciLexerVHDL_SetFoldAtParenthesis(self *C.QsciLexerVHDL
 	gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_SetFoldAtParenthesis, slotval1)
 
 }
-
-func (this *QsciLexerVHDL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerVHDL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerVHDL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerVHDL) OnLanguage(slot func() string) {
 	C.QsciLexerVHDL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVHDL_Language
 func miqt_exec_callback_QsciLexerVHDL_Language(self *C.QsciLexerVHDL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -821,21 +814,13 @@ func miqt_exec_callback_QsciLexerVHDL_DefaultStyle(self *C.QsciLexerVHDL, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerVHDL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerVHDL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerVHDL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerVHDL) OnDescription(slot func(style int) string) {
 	C.QsciLexerVHDL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVHDL_Description
 func miqt_exec_callback_QsciLexerVHDL_Description(self *C.QsciLexerVHDL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -843,7 +828,7 @@ func miqt_exec_callback_QsciLexerVHDL_Description(self *C.QsciLexerVHDL, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla/gen_qscilexeryaml.go

@@ -246,25 +246,18 @@ func miqt_exec_callback_QsciLexerYAML_SetFoldComments(self *C.QsciLexerYAML, cb
 	gofunc((&QsciLexerYAML{h: self}).callVirtualBase_SetFoldComments, slotval1)
 
 }
-
-func (this *QsciLexerYAML) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerYAML_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerYAML) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerYAML) OnLanguage(slot func() string) {
 	C.QsciLexerYAML_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerYAML_Language
 func miqt_exec_callback_QsciLexerYAML_Language(self *C.QsciLexerYAML, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerYAML{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -687,21 +680,13 @@ func miqt_exec_callback_QsciLexerYAML_DefaultStyle(self *C.QsciLexerYAML, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerYAML) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerYAML_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerYAML) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerYAML) OnDescription(slot func(style int) string) {
 	C.QsciLexerYAML_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerYAML_Description
 func miqt_exec_callback_QsciLexerYAML_Description(self *C.QsciLexerYAML, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -709,7 +694,7 @@ func miqt_exec_callback_QsciLexerYAML_Description(self *C.QsciLexerYAML, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerYAML{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qsciabstractapis.cpp

@@ -1,13 +1,336 @@
+#include <QChildEvent>
+#include <QEvent>
 #include <QList>
+#include <QMetaMethod>
 #include <QMetaObject>
 #include <QObject>
 #include <QString>
 #include <QByteArray>
 #include <cstring>
+#include <QTimerEvent>
 #include <qsciabstractapis.h>
 #include "gen_qsciabstractapis.h"
 #include "_cgo_export.h"
 
+class MiqtVirtualQsciAbstractAPIs : public virtual QsciAbstractAPIs {
+public:
+
+	MiqtVirtualQsciAbstractAPIs(QsciLexer* lexer): QsciAbstractAPIs(lexer) {};
+
+	virtual ~MiqtVirtualQsciAbstractAPIs() = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateAutoCompletionList = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateAutoCompletionList(const QStringList& context, QStringList& list) override {
+		if (handle__UpdateAutoCompletionList == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		const QStringList& context_ret = context;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* context_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * context_ret.length()));
+		for (size_t i = 0, e = context_ret.length(); i < e; ++i) {
+			QString context_lv_ret = context_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray context_lv_b = context_lv_ret.toUtf8();
+			struct miqt_string context_lv_ms;
+			context_lv_ms.len = context_lv_b.length();
+			context_lv_ms.data = static_cast<char*>(malloc(context_lv_ms.len));
+			memcpy(context_lv_ms.data, context_lv_b.data(), context_lv_ms.len);
+			context_arr[i] = context_lv_ms;
+		}
+		struct miqt_array context_out;
+		context_out.len = context_ret.length();
+		context_out.data = static_cast<void*>(context_arr);
+		struct miqt_array /* of struct miqt_string */  sigval1 = context_out;
+		QStringList& list_ret = list;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* list_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * list_ret.length()));
+		for (size_t i = 0, e = list_ret.length(); i < e; ++i) {
+			QString list_lv_ret = list_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray list_lv_b = list_lv_ret.toUtf8();
+			struct miqt_string list_lv_ms;
+			list_lv_ms.len = list_lv_b.length();
+			list_lv_ms.data = static_cast<char*>(malloc(list_lv_ms.len));
+			memcpy(list_lv_ms.data, list_lv_b.data(), list_lv_ms.len);
+			list_arr[i] = list_lv_ms;
+		}
+		struct miqt_array list_out;
+		list_out.len = list_ret.length();
+		list_out.data = static_cast<void*>(list_arr);
+		struct miqt_array /* of struct miqt_string */  sigval2 = list_out;
+
+		miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList(this, handle__UpdateAutoCompletionList, sigval1, sigval2);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__AutoCompletionSelected = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void autoCompletionSelected(const QString& selection) override {
+		if (handle__AutoCompletionSelected == 0) {
+			QsciAbstractAPIs::autoCompletionSelected(selection);
+			return;
+		}
+		
+		const QString selection_ret = selection;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray selection_b = selection_ret.toUtf8();
+		struct miqt_string selection_ms;
+		selection_ms.len = selection_b.length();
+		selection_ms.data = static_cast<char*>(malloc(selection_ms.len));
+		memcpy(selection_ms.data, selection_b.data(), selection_ms.len);
+		struct miqt_string sigval1 = selection_ms;
+
+		miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected(this, handle__AutoCompletionSelected, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_AutoCompletionSelected(struct miqt_string selection) {
+		QString selection_QString = QString::fromUtf8(selection.data, selection.len);
+
+		QsciAbstractAPIs::autoCompletionSelected(selection_QString);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CallTips = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QStringList callTips(const QStringList& context, int commas, QsciScintilla::CallTipsStyle style, QList<int>& shifts) override {
+		if (handle__CallTips == 0) {
+			return QStringList(); // Pure virtual, there is no base we can call
+		}
+		
+		const QStringList& context_ret = context;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		struct miqt_string* context_arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * context_ret.length()));
+		for (size_t i = 0, e = context_ret.length(); i < e; ++i) {
+			QString context_lv_ret = context_ret[i];
+			// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+			QByteArray context_lv_b = context_lv_ret.toUtf8();
+			struct miqt_string context_lv_ms;
+			context_lv_ms.len = context_lv_b.length();
+			context_lv_ms.data = static_cast<char*>(malloc(context_lv_ms.len));
+			memcpy(context_lv_ms.data, context_lv_b.data(), context_lv_ms.len);
+			context_arr[i] = context_lv_ms;
+		}
+		struct miqt_array context_out;
+		context_out.len = context_ret.length();
+		context_out.data = static_cast<void*>(context_arr);
+		struct miqt_array /* of struct miqt_string */  sigval1 = context_out;
+		int sigval2 = commas;
+		QsciScintilla::CallTipsStyle style_ret = style;
+		int sigval3 = static_cast<int>(style_ret);
+		QList<int>& shifts_ret = shifts;
+		// Convert QList<> from C++ memory to manually-managed C memory
+		int* shifts_arr = static_cast<int*>(malloc(sizeof(int) * shifts_ret.length()));
+		for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) {
+			shifts_arr[i] = shifts_ret[i];
+		}
+		struct miqt_array shifts_out;
+		shifts_out.len = shifts_ret.length();
+		shifts_out.data = static_cast<void*>(shifts_arr);
+		struct miqt_array /* of int */  sigval4 = shifts_out;
+
+		struct miqt_array /* of struct miqt_string */  callback_return_value = miqt_exec_callback_QsciAbstractAPIs_CallTips(this, handle__CallTips, sigval1, sigval2, sigval3, sigval4);
+		QStringList callback_return_value_QList;
+		callback_return_value_QList.reserve(callback_return_value.len);
+		struct miqt_string* callback_return_value_arr = static_cast<struct miqt_string*>(callback_return_value.data);
+		for(size_t i = 0; i < callback_return_value.len; ++i) {
+			QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len);
+			callback_return_value_QList.push_back(callback_return_value_arr_i_QString);
+		}
+
+		return callback_return_value_QList;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__Event == 0) {
+			return QsciAbstractAPIs::event(event);
+		}
+		
+		QEvent* sigval1 = event;
+
+		bool callback_return_value = miqt_exec_callback_QsciAbstractAPIs_Event(this, handle__Event, sigval1);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_Event(QEvent* event) {
+
+		return QsciAbstractAPIs::event(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__EventFilter == 0) {
+			return QsciAbstractAPIs::eventFilter(watched, event);
+		}
+		
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+
+		bool callback_return_value = miqt_exec_callback_QsciAbstractAPIs_EventFilter(this, handle__EventFilter, sigval1, sigval2);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
+
+		return QsciAbstractAPIs::eventFilter(watched, event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__TimerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__TimerEvent == 0) {
+			QsciAbstractAPIs::timerEvent(event);
+			return;
+		}
+		
+		QTimerEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_TimerEvent(this, handle__TimerEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_TimerEvent(QTimerEvent* event) {
+
+		QsciAbstractAPIs::timerEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ChildEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__ChildEvent == 0) {
+			QsciAbstractAPIs::childEvent(event);
+			return;
+		}
+		
+		QChildEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_ChildEvent(this, handle__ChildEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ChildEvent(QChildEvent* event) {
+
+		QsciAbstractAPIs::childEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CustomEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__CustomEvent == 0) {
+			QsciAbstractAPIs::customEvent(event);
+			return;
+		}
+		
+		QEvent* sigval1 = event;
+
+		miqt_exec_callback_QsciAbstractAPIs_CustomEvent(this, handle__CustomEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_CustomEvent(QEvent* event) {
+
+		QsciAbstractAPIs::customEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ConnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__ConnectNotify == 0) {
+			QsciAbstractAPIs::connectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QsciAbstractAPIs_ConnectNotify(this, handle__ConnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ConnectNotify(QMetaMethod* signal) {
+
+		QsciAbstractAPIs::connectNotify(*signal);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DisconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__DisconnectNotify == 0) {
+			QsciAbstractAPIs::disconnectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DisconnectNotify(QMetaMethod* signal) {
+
+		QsciAbstractAPIs::disconnectNotify(*signal);
+
+	}
+
+};
+
+void QsciAbstractAPIs_new(QsciLexer* lexer, QsciAbstractAPIs** outptr_QsciAbstractAPIs, QObject** outptr_QObject) {
+	MiqtVirtualQsciAbstractAPIs* ret = new MiqtVirtualQsciAbstractAPIs(lexer);
+	*outptr_QsciAbstractAPIs = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
 QMetaObject* QsciAbstractAPIs_MetaObject(const QsciAbstractAPIs* self) {
 	return (QMetaObject*) self->metaObject();
 }
@@ -109,9 +432,81 @@ struct miqt_string QsciAbstractAPIs_Tr3(const char* s, const char* c, int n) {
 	return _ms;
 }
 
+void QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__UpdateAutoCompletionList = slot;
+}
+
+void QsciAbstractAPIs_override_virtual_AutoCompletionSelected(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__AutoCompletionSelected = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_AutoCompletionSelected(void* self, struct miqt_string selection) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_AutoCompletionSelected(selection);
+}
+
+void QsciAbstractAPIs_override_virtual_CallTips(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__CallTips = slot;
+}
+
+void QsciAbstractAPIs_override_virtual_Event(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__Event = slot;
+}
+
+bool QsciAbstractAPIs_virtualbase_Event(void* self, QEvent* event) {
+	return ( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_Event(event);
+}
+
+void QsciAbstractAPIs_override_virtual_EventFilter(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__EventFilter = slot;
+}
+
+bool QsciAbstractAPIs_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
+	return ( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_EventFilter(watched, event);
+}
+
+void QsciAbstractAPIs_override_virtual_TimerEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__TimerEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_TimerEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_ChildEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__ChildEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_ChildEvent(void* self, QChildEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_ChildEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_CustomEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__CustomEvent = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_CustomEvent(void* self, QEvent* event) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_CustomEvent(event);
+}
+
+void QsciAbstractAPIs_override_virtual_ConnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__ConnectNotify = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_ConnectNotify(signal);
+}
+
+void QsciAbstractAPIs_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( (QsciAbstractAPIs*)(self) )->handle__DisconnectNotify = slot;
+}
+
+void QsciAbstractAPIs_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQsciAbstractAPIs*)(self) )->virtualbase_DisconnectNotify(signal);
+}
+
 void QsciAbstractAPIs_Delete(QsciAbstractAPIs* self, bool isSubclass) {
 	if (isSubclass) {
-		delete dynamic_cast<QsciAbstractAPIs*>( self );
+		delete dynamic_cast<MiqtVirtualQsciAbstractAPIs*>( self );
 	} else {
 		delete self;
 	}

qt-restricted-extras/qscintilla6/gen_qsciabstractapis.go

@@ -11,6 +11,7 @@ import "C"
 import (
 	"github.com/mappu/miqt/qt6"
 	"runtime"
+	"runtime/cgo"
 	"unsafe"
 )
 
@@ -53,6 +54,17 @@ func UnsafeNewQsciAbstractAPIs(h unsafe.Pointer, h_QObject unsafe.Pointer) *Qsci
 		QObject: qt6.UnsafeNewQObject(h_QObject)}
 }
 
+// NewQsciAbstractAPIs constructs a new QsciAbstractAPIs object.
+func NewQsciAbstractAPIs(lexer *QsciLexer) *QsciAbstractAPIs {
+	var outptr_QsciAbstractAPIs *C.QsciAbstractAPIs = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciAbstractAPIs_new(lexer.cPointer(), &outptr_QsciAbstractAPIs, &outptr_QObject)
+	ret := newQsciAbstractAPIs(outptr_QsciAbstractAPIs, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QsciAbstractAPIs) MetaObject() *qt6.QMetaObject {
 	return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QsciAbstractAPIs_MetaObject(this.h)))
 }
@@ -158,6 +170,289 @@ func QsciAbstractAPIs_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
+func (this *QsciAbstractAPIs) OnUpdateAutoCompletionList(slot func(context []string, list []string)) {
+	C.QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList
+func miqt_exec_callback_QsciAbstractAPIs_UpdateAutoCompletionList(self *C.QsciAbstractAPIs, cb C.intptr_t, context C.struct_miqt_array, list C.struct_miqt_array) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(context []string, list []string))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var context_ma C.struct_miqt_array = context
+	context_ret := make([]string, int(context_ma.len))
+	context_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(context_ma.data)) // hey ya
+	for i := 0; i < int(context_ma.len); i++ {
+		var context_lv_ms C.struct_miqt_string = context_outCast[i]
+		context_lv_ret := C.GoStringN(context_lv_ms.data, C.int(int64(context_lv_ms.len)))
+		C.free(unsafe.Pointer(context_lv_ms.data))
+		context_ret[i] = context_lv_ret
+	}
+	slotval1 := context_ret
+
+	var list_ma C.struct_miqt_array = list
+	list_ret := make([]string, int(list_ma.len))
+	list_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(list_ma.data)) // hey ya
+	for i := 0; i < int(list_ma.len); i++ {
+		var list_lv_ms C.struct_miqt_string = list_outCast[i]
+		list_lv_ret := C.GoStringN(list_lv_ms.data, C.int(int64(list_lv_ms.len)))
+		C.free(unsafe.Pointer(list_lv_ms.data))
+		list_ret[i] = list_lv_ret
+	}
+	slotval2 := list_ret
+
+	gofunc(slotval1, slotval2)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_AutoCompletionSelected(selection string) {
+	selection_ms := C.struct_miqt_string{}
+	selection_ms.data = C.CString(selection)
+	selection_ms.len = C.size_t(len(selection))
+	defer C.free(unsafe.Pointer(selection_ms.data))
+
+	C.QsciAbstractAPIs_virtualbase_AutoCompletionSelected(unsafe.Pointer(this.h), selection_ms)
+
+}
+func (this *QsciAbstractAPIs) OnAutoCompletionSelected(slot func(super func(selection string), selection string)) {
+	C.QsciAbstractAPIs_override_virtual_AutoCompletionSelected(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected
+func miqt_exec_callback_QsciAbstractAPIs_AutoCompletionSelected(self *C.QsciAbstractAPIs, cb C.intptr_t, selection C.struct_miqt_string) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(selection string), selection string))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var selection_ms C.struct_miqt_string = selection
+	selection_ret := C.GoStringN(selection_ms.data, C.int(int64(selection_ms.len)))
+	C.free(unsafe.Pointer(selection_ms.data))
+	slotval1 := selection_ret
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_AutoCompletionSelected, slotval1)
+
+}
+func (this *QsciAbstractAPIs) OnCallTips(slot func(context []string, commas int, style QsciScintilla__CallTipsStyle, shifts []int) []string) {
+	C.QsciAbstractAPIs_override_virtual_CallTips(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_CallTips
+func miqt_exec_callback_QsciAbstractAPIs_CallTips(self *C.QsciAbstractAPIs, cb C.intptr_t, context C.struct_miqt_array, commas C.int, style C.int, shifts C.struct_miqt_array) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(context []string, commas int, style QsciScintilla__CallTipsStyle, shifts []int) []string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var context_ma C.struct_miqt_array = context
+	context_ret := make([]string, int(context_ma.len))
+	context_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(context_ma.data)) // hey ya
+	for i := 0; i < int(context_ma.len); i++ {
+		var context_lv_ms C.struct_miqt_string = context_outCast[i]
+		context_lv_ret := C.GoStringN(context_lv_ms.data, C.int(int64(context_lv_ms.len)))
+		C.free(unsafe.Pointer(context_lv_ms.data))
+		context_ret[i] = context_lv_ret
+	}
+	slotval1 := context_ret
+
+	slotval2 := (int)(commas)
+
+	slotval3 := (QsciScintilla__CallTipsStyle)(style)
+
+	var shifts_ma C.struct_miqt_array = shifts
+	shifts_ret := make([]int, int(shifts_ma.len))
+	shifts_outCast := (*[0xffff]C.int)(unsafe.Pointer(shifts_ma.data)) // hey ya
+	for i := 0; i < int(shifts_ma.len); i++ {
+		shifts_ret[i] = (int)(shifts_outCast[i])
+	}
+	slotval4 := shifts_ret
+
+	virtualReturn := gofunc(slotval1, slotval2, slotval3, slotval4)
+	virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_i_ms := C.struct_miqt_string{}
+		virtualReturn_i_ms.data = C.CString(virtualReturn[i])
+		virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i]))
+		defer C.free(unsafe.Pointer(virtualReturn_i_ms.data))
+		virtualReturn_CArray[i] = virtualReturn_i_ms
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_Event(event *qt6.QEvent) bool {
+
+	return (bool)(C.QsciAbstractAPIs_virtualbase_Event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QsciAbstractAPIs) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) {
+	C.QsciAbstractAPIs_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_Event
+func miqt_exec_callback_QsciAbstractAPIs_Event(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool {
+
+	return (bool)(C.QsciAbstractAPIs_virtualbase_EventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QsciAbstractAPIs) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) {
+	C.QsciAbstractAPIs_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_EventFilter
+func miqt_exec_callback_QsciAbstractAPIs_EventFilter(self *C.QsciAbstractAPIs, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched))
+	slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_TimerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) {
+	C.QsciAbstractAPIs_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_TimerEvent
+func miqt_exec_callback_QsciAbstractAPIs_TimerEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_ChildEvent(event *qt6.QChildEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_ChildEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) {
+	C.QsciAbstractAPIs_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_ChildEvent
+func miqt_exec_callback_QsciAbstractAPIs_ChildEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_CustomEvent(event *qt6.QEvent) {
+
+	C.QsciAbstractAPIs_virtualbase_CustomEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) {
+	C.QsciAbstractAPIs_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_CustomEvent
+func miqt_exec_callback_QsciAbstractAPIs_CustomEvent(self *C.QsciAbstractAPIs, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) {
+
+	C.QsciAbstractAPIs_virtualbase_ConnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) {
+	C.QsciAbstractAPIs_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_ConnectNotify
+func miqt_exec_callback_QsciAbstractAPIs_ConnectNotify(self *C.QsciAbstractAPIs, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QsciAbstractAPIs) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) {
+
+	C.QsciAbstractAPIs_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QsciAbstractAPIs) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) {
+	C.QsciAbstractAPIs_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify
+func miqt_exec_callback_QsciAbstractAPIs_DisconnectNotify(self *C.QsciAbstractAPIs, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QsciAbstractAPIs{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QsciAbstractAPIs) Delete() {

qt-restricted-extras/qscintilla6/gen_qsciabstractapis.h

@@ -15,17 +15,26 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
 class QMetaObject;
 class QObject;
+class QTimerEvent;
 class QsciAbstractAPIs;
 class QsciLexer;
 #else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QsciAbstractAPIs QsciAbstractAPIs;
 typedef struct QsciLexer QsciLexer;
 #endif
 
+void QsciAbstractAPIs_new(QsciLexer* lexer, QsciAbstractAPIs** outptr_QsciAbstractAPIs, QObject** outptr_QObject);
 QMetaObject* QsciAbstractAPIs_MetaObject(const QsciAbstractAPIs* self);
 void* QsciAbstractAPIs_Metacast(QsciAbstractAPIs* self, const char* param1);
 struct miqt_string QsciAbstractAPIs_Tr(const char* s);
@@ -35,6 +44,26 @@ void QsciAbstractAPIs_AutoCompletionSelected(QsciAbstractAPIs* self, struct miqt
 struct miqt_array /* of struct miqt_string */  QsciAbstractAPIs_CallTips(QsciAbstractAPIs* self, struct miqt_array /* of struct miqt_string */  context, int commas, int style, struct miqt_array /* of int */  shifts);
 struct miqt_string QsciAbstractAPIs_Tr2(const char* s, const char* c);
 struct miqt_string QsciAbstractAPIs_Tr3(const char* s, const char* c, int n);
+void QsciAbstractAPIs_override_virtual_UpdateAutoCompletionList(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_UpdateAutoCompletionList(void* self, struct miqt_array /* of struct miqt_string */  context, struct miqt_array /* of struct miqt_string */  list);
+void QsciAbstractAPIs_override_virtual_AutoCompletionSelected(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_AutoCompletionSelected(void* self, struct miqt_string selection);
+void QsciAbstractAPIs_override_virtual_CallTips(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciAbstractAPIs_virtualbase_CallTips(void* self, struct miqt_array /* of struct miqt_string */  context, int commas, int style, struct miqt_array /* of int */  shifts);
+void QsciAbstractAPIs_override_virtual_Event(void* self, intptr_t slot);
+bool QsciAbstractAPIs_virtualbase_Event(void* self, QEvent* event);
+void QsciAbstractAPIs_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QsciAbstractAPIs_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QsciAbstractAPIs_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QsciAbstractAPIs_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QsciAbstractAPIs_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_CustomEvent(void* self, QEvent* event);
+void QsciAbstractAPIs_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QsciAbstractAPIs_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QsciAbstractAPIs_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QsciAbstractAPIs_Delete(QsciAbstractAPIs* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla6/gen_qscilexer.h

@@ -15,25 +15,35 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QChildEvent;
 class QColor;
+class QEvent;
 class QFont;
+class QMetaMethod;
 class QMetaObject;
 class QObject;
 class QSettings;
+class QTimerEvent;
 class QsciAbstractAPIs;
 class QsciLexer;
 class QsciScintilla;
 #else
+typedef struct QChildEvent QChildEvent;
 typedef struct QColor QColor;
+typedef struct QEvent QEvent;
 typedef struct QFont QFont;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
 typedef struct QSettings QSettings;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QsciAbstractAPIs QsciAbstractAPIs;
 typedef struct QsciLexer QsciLexer;
 typedef struct QsciScintilla QsciScintilla;
 #endif
 
+void QsciLexer_new(QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
+void QsciLexer_new2(QObject* parent, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
 QMetaObject* QsciLexer_MetaObject(const QsciLexer* self);
 void* QsciLexer_Metacast(QsciLexer* self, const char* param1);
 struct miqt_string QsciLexer_Tr(const char* s);
@@ -97,6 +107,88 @@ struct miqt_string QsciLexer_Tr2(const char* s, const char* c);
 struct miqt_string QsciLexer_Tr3(const char* s, const char* c, int n);
 bool QsciLexer_ReadSettings2(QsciLexer* self, QSettings* qs, const char* prefix);
 bool QsciLexer_WriteSettings2(const QsciLexer* self, QSettings* qs, const char* prefix);
+void QsciLexer_override_virtual_Language(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Language(const void* self);
+void QsciLexer_override_virtual_Lexer(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Lexer(const void* self);
+void QsciLexer_override_virtual_LexerId(void* self, intptr_t slot);
+int QsciLexer_virtualbase_LexerId(const void* self);
+void QsciLexer_override_virtual_AutoCompletionFillups(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_AutoCompletionFillups(const void* self);
+void QsciLexer_override_virtual_AutoCompletionWordSeparators(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciLexer_virtualbase_AutoCompletionWordSeparators(const void* self);
+void QsciLexer_override_virtual_BlockEnd(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockEnd(const void* self, int* style);
+void QsciLexer_override_virtual_BlockLookback(void* self, intptr_t slot);
+int QsciLexer_virtualbase_BlockLookback(const void* self);
+void QsciLexer_override_virtual_BlockStart(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockStart(const void* self, int* style);
+void QsciLexer_override_virtual_BlockStartKeyword(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_BlockStartKeyword(const void* self, int* style);
+void QsciLexer_override_virtual_BraceStyle(void* self, intptr_t slot);
+int QsciLexer_virtualbase_BraceStyle(const void* self);
+void QsciLexer_override_virtual_CaseSensitive(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_CaseSensitive(const void* self);
+void QsciLexer_override_virtual_Color(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_Color(const void* self, int style);
+void QsciLexer_override_virtual_EolFill(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_EolFill(const void* self, int style);
+void QsciLexer_override_virtual_Font(void* self, intptr_t slot);
+QFont* QsciLexer_virtualbase_Font(const void* self, int style);
+void QsciLexer_override_virtual_IndentationGuideView(void* self, intptr_t slot);
+int QsciLexer_virtualbase_IndentationGuideView(const void* self);
+void QsciLexer_override_virtual_Keywords(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_Keywords(const void* self, int set);
+void QsciLexer_override_virtual_DefaultStyle(void* self, intptr_t slot);
+int QsciLexer_virtualbase_DefaultStyle(const void* self);
+void QsciLexer_override_virtual_Description(void* self, intptr_t slot);
+struct miqt_string QsciLexer_virtualbase_Description(const void* self, int style);
+void QsciLexer_override_virtual_Paper(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_Paper(const void* self, int style);
+void QsciLexer_override_virtual_DefaultColorWithStyle(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_DefaultColorWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_DefaultEolFill(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_DefaultEolFill(const void* self, int style);
+void QsciLexer_override_virtual_DefaultFontWithStyle(void* self, intptr_t slot);
+QFont* QsciLexer_virtualbase_DefaultFontWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_DefaultPaperWithStyle(void* self, intptr_t slot);
+QColor* QsciLexer_virtualbase_DefaultPaperWithStyle(const void* self, int style);
+void QsciLexer_override_virtual_SetEditor(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetEditor(void* self, QsciScintilla* editor);
+void QsciLexer_override_virtual_RefreshProperties(void* self, intptr_t slot);
+void QsciLexer_virtualbase_RefreshProperties(void* self);
+void QsciLexer_override_virtual_StyleBitsNeeded(void* self, intptr_t slot);
+int QsciLexer_virtualbase_StyleBitsNeeded(const void* self);
+void QsciLexer_override_virtual_WordCharacters(void* self, intptr_t slot);
+const char* QsciLexer_virtualbase_WordCharacters(const void* self);
+void QsciLexer_override_virtual_SetAutoIndentStyle(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetAutoIndentStyle(void* self, int autoindentstyle);
+void QsciLexer_override_virtual_SetColor(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetColor(void* self, QColor* c, int style);
+void QsciLexer_override_virtual_SetEolFill(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetEolFill(void* self, bool eoffill, int style);
+void QsciLexer_override_virtual_SetFont(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetFont(void* self, QFont* f, int style);
+void QsciLexer_override_virtual_SetPaper(void* self, intptr_t slot);
+void QsciLexer_virtualbase_SetPaper(void* self, QColor* c, int style);
+void QsciLexer_override_virtual_ReadProperties(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_ReadProperties(void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexer_override_virtual_WriteProperties(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_WriteProperties(const void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexer_override_virtual_Event(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_Event(void* self, QEvent* event);
+void QsciLexer_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QsciLexer_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QsciLexer_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QsciLexer_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QsciLexer_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QsciLexer_virtualbase_CustomEvent(void* self, QEvent* event);
+void QsciLexer_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QsciLexer_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QsciLexer_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QsciLexer_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QsciLexer_Delete(QsciLexer* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla6/gen_qscilexeravs.go

@@ -249,25 +249,18 @@ func miqt_exec_callback_QsciLexerAVS_SetFoldCompact(self *C.QsciLexerAVS, cb C.i
 	gofunc((&QsciLexerAVS{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerAVS) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerAVS_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerAVS) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerAVS) OnLanguage(slot func() string) {
 	C.QsciLexerAVS_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerAVS_Language
 func miqt_exec_callback_QsciLexerAVS_Language(self *C.QsciLexerAVS, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerAVS{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -690,21 +683,13 @@ func miqt_exec_callback_QsciLexerAVS_DefaultStyle(self *C.QsciLexerAVS, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerAVS) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerAVS_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerAVS) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerAVS) OnDescription(slot func(style int) string) {
 	C.QsciLexerAVS_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerAVS_Description
 func miqt_exec_callback_QsciLexerAVS_Description(self *C.QsciLexerAVS, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -712,7 +697,7 @@ func miqt_exec_callback_QsciLexerAVS_Description(self *C.QsciLexerAVS, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerAVS{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerbash.go

@@ -259,25 +259,18 @@ func miqt_exec_callback_QsciLexerBash_SetFoldCompact(self *C.QsciLexerBash, cb C
 	gofunc((&QsciLexerBash{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerBash) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerBash_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerBash) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerBash) OnLanguage(slot func() string) {
 	C.QsciLexerBash_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBash_Language
 func miqt_exec_callback_QsciLexerBash_Language(self *C.QsciLexerBash, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerBash{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -700,21 +693,13 @@ func miqt_exec_callback_QsciLexerBash_DefaultStyle(self *C.QsciLexerBash, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerBash) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerBash_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerBash) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerBash) OnDescription(slot func(style int) string) {
 	C.QsciLexerBash_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBash_Description
 func miqt_exec_callback_QsciLexerBash_Description(self *C.QsciLexerBash, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -722,7 +707,7 @@ func miqt_exec_callback_QsciLexerBash_Description(self *C.QsciLexerBash, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerBash{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerbatch.go

@@ -187,25 +187,18 @@ func QsciLexerBatch_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerBatch) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerBatch_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerBatch) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerBatch) OnLanguage(slot func() string) {
 	C.QsciLexerBatch_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBatch_Language
 func miqt_exec_callback_QsciLexerBatch_Language(self *C.QsciLexerBatch, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerBatch{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -628,21 +621,13 @@ func miqt_exec_callback_QsciLexerBatch_DefaultStyle(self *C.QsciLexerBatch, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerBatch) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerBatch_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerBatch) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerBatch) OnDescription(slot func(style int) string) {
 	C.QsciLexerBatch_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerBatch_Description
 func miqt_exec_callback_QsciLexerBatch_Description(self *C.QsciLexerBatch, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -650,7 +635,7 @@ func miqt_exec_callback_QsciLexerBatch_Description(self *C.QsciLexerBatch, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerBatch{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexercmake.go

@@ -216,25 +216,18 @@ func miqt_exec_callback_QsciLexerCMake_SetFoldAtElse(self *C.QsciLexerCMake, cb
 	gofunc((&QsciLexerCMake{h: self}).callVirtualBase_SetFoldAtElse, slotval1)
 
 }
-
-func (this *QsciLexerCMake) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCMake_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCMake) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCMake) OnLanguage(slot func() string) {
 	C.QsciLexerCMake_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCMake_Language
 func miqt_exec_callback_QsciLexerCMake_Language(self *C.QsciLexerCMake, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCMake{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -657,21 +650,13 @@ func miqt_exec_callback_QsciLexerCMake_DefaultStyle(self *C.QsciLexerCMake, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCMake) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCMake_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCMake) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCMake) OnDescription(slot func(style int) string) {
 	C.QsciLexerCMake_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCMake_Description
 func miqt_exec_callback_QsciLexerCMake_Description(self *C.QsciLexerCMake, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -679,7 +664,7 @@ func miqt_exec_callback_QsciLexerCMake_Description(self *C.QsciLexerCMake, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCMake{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexercoffeescript.go

@@ -282,25 +282,18 @@ func (this *QsciLexerCoffeeScript) BlockStartKeyword1(style *int) string {
 	_ret := C.QsciLexerCoffeeScript_BlockStartKeyword1(this.h, (*C.int)(unsafe.Pointer(style)))
 	return C.GoString(_ret)
 }
-
-func (this *QsciLexerCoffeeScript) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCoffeeScript_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCoffeeScript) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCoffeeScript) OnLanguage(slot func() string) {
 	C.QsciLexerCoffeeScript_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCoffeeScript_Language
 func miqt_exec_callback_QsciLexerCoffeeScript_Language(self *C.QsciLexerCoffeeScript, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCoffeeScript{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -723,21 +716,13 @@ func miqt_exec_callback_QsciLexerCoffeeScript_DefaultStyle(self *C.QsciLexerCoff
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCoffeeScript) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCoffeeScript_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCoffeeScript) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCoffeeScript) OnDescription(slot func(style int) string) {
 	C.QsciLexerCoffeeScript_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCoffeeScript_Description
 func miqt_exec_callback_QsciLexerCoffeeScript_Description(self *C.QsciLexerCoffeeScript, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -745,7 +730,7 @@ func miqt_exec_callback_QsciLexerCoffeeScript_Description(self *C.QsciLexerCoffe
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCoffeeScript{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexercpp.go

@@ -497,25 +497,18 @@ func miqt_exec_callback_QsciLexerCPP_SetStylePreprocessor(self *C.QsciLexerCPP,
 	gofunc((&QsciLexerCPP{h: self}).callVirtualBase_SetStylePreprocessor, slotval1)
 
 }
-
-func (this *QsciLexerCPP) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCPP_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCPP) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCPP) OnLanguage(slot func() string) {
 	C.QsciLexerCPP_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCPP_Language
 func miqt_exec_callback_QsciLexerCPP_Language(self *C.QsciLexerCPP, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCPP{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -938,21 +931,13 @@ func miqt_exec_callback_QsciLexerCPP_DefaultStyle(self *C.QsciLexerCPP, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCPP) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCPP_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCPP) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCPP) OnDescription(slot func(style int) string) {
 	C.QsciLexerCPP_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCPP_Description
 func miqt_exec_callback_QsciLexerCPP_Description(self *C.QsciLexerCPP, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -960,7 +945,7 @@ func miqt_exec_callback_QsciLexerCPP_Description(self *C.QsciLexerCPP, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCPP{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexercss.go

@@ -298,25 +298,18 @@ func miqt_exec_callback_QsciLexerCSS_SetFoldCompact(self *C.QsciLexerCSS, cb C.i
 	gofunc((&QsciLexerCSS{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerCSS) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerCSS_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerCSS) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerCSS) OnLanguage(slot func() string) {
 	C.QsciLexerCSS_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCSS_Language
 func miqt_exec_callback_QsciLexerCSS_Language(self *C.QsciLexerCSS, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerCSS{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -739,21 +732,13 @@ func miqt_exec_callback_QsciLexerCSS_DefaultStyle(self *C.QsciLexerCSS, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerCSS) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerCSS_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerCSS) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerCSS) OnDescription(slot func(style int) string) {
 	C.QsciLexerCSS_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerCSS_Description
 func miqt_exec_callback_QsciLexerCSS_Description(self *C.QsciLexerCSS, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -761,7 +746,7 @@ func miqt_exec_callback_QsciLexerCSS_Description(self *C.QsciLexerCSS, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerCSS{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexercustom.go

@@ -11,6 +11,7 @@ import "C"
 import (
 	"github.com/mappu/miqt/qt6"
 	"runtime"
+	"runtime/cgo"
 	"unsafe"
 )
 
@@ -53,6 +54,30 @@ func UnsafeNewQsciLexerCustom(h unsafe.Pointer, h_QsciLexer unsafe.Pointer, h_QO
 		QsciLexer: UnsafeNewQsciLexer(h_QsciLexer, h_QObject)}
 }
 
+// NewQsciLexerCustom constructs a new QsciLexerCustom object.
+func NewQsciLexerCustom() *QsciLexerCustom {
+	var outptr_QsciLexerCustom *C.QsciLexerCustom = nil
+	var outptr_QsciLexer *C.QsciLexer = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciLexerCustom_new(&outptr_QsciLexerCustom, &outptr_QsciLexer, &outptr_QObject)
+	ret := newQsciLexerCustom(outptr_QsciLexerCustom, outptr_QsciLexer, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
+// NewQsciLexerCustom2 constructs a new QsciLexerCustom object.
+func NewQsciLexerCustom2(parent *qt6.QObject) *QsciLexerCustom {
+	var outptr_QsciLexerCustom *C.QsciLexerCustom = nil
+	var outptr_QsciLexer *C.QsciLexer = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QsciLexerCustom_new2((*C.QObject)(parent.UnsafePointer()), &outptr_QsciLexerCustom, &outptr_QsciLexer, &outptr_QObject)
+	ret := newQsciLexerCustom(outptr_QsciLexerCustom, outptr_QsciLexer, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QsciLexerCustom) MetaObject() *qt6.QMetaObject {
 	return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QsciLexerCustom_MetaObject(this.h)))
 }
@@ -121,6 +146,895 @@ func QsciLexerCustom_Tr3(s string, c string, n int) string {
 func (this *QsciLexerCustom) StartStyling2(pos int, styleBits int) {
 	C.QsciLexerCustom_StartStyling2(this.h, (C.int)(pos), (C.int)(styleBits))
 }
+func (this *QsciLexerCustom) OnStyleText(slot func(start int, end int)) {
+	C.QsciLexerCustom_override_virtual_StyleText(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_StyleText
+func miqt_exec_callback_QsciLexerCustom_StyleText(self *C.QsciLexerCustom, cb C.intptr_t, start C.int, end C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(start int, end int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(start)
+
+	slotval2 := (int)(end)
+
+	gofunc(slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetEditor(editor *QsciScintilla) {
+
+	C.QsciLexerCustom_virtualbase_SetEditor(unsafe.Pointer(this.h), editor.cPointer())
+
+}
+func (this *QsciLexerCustom) OnSetEditor(slot func(super func(editor *QsciScintilla), editor *QsciScintilla)) {
+	C.QsciLexerCustom_override_virtual_SetEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetEditor
+func miqt_exec_callback_QsciLexerCustom_SetEditor(self *C.QsciLexerCustom, cb C.intptr_t, editor *C.QsciScintilla) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QsciScintilla), editor *QsciScintilla))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQsciScintilla(unsafe.Pointer(editor), nil, nil, nil, nil, nil, nil)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetEditor, slotval1)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_StyleBitsNeeded() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_StyleBitsNeeded(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnStyleBitsNeeded(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_StyleBitsNeeded(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_StyleBitsNeeded
+func miqt_exec_callback_QsciLexerCustom_StyleBitsNeeded(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_StyleBitsNeeded)
+
+	return (C.int)(virtualReturn)
+
+}
+func (this *QsciLexerCustom) OnLanguage(slot func() string) {
+	C.QsciLexerCustom_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Language
+func miqt_exec_callback_QsciLexerCustom_Language(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc()
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Lexer() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_Lexer(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnLexer(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_Lexer(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Lexer
+func miqt_exec_callback_QsciLexerCustom_Lexer(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Lexer)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_LexerId() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_LexerId(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnLexerId(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_LexerId(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_LexerId
+func miqt_exec_callback_QsciLexerCustom_LexerId(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_LexerId)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_AutoCompletionFillups() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_AutoCompletionFillups(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnAutoCompletionFillups(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_AutoCompletionFillups(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_AutoCompletionFillups
+func miqt_exec_callback_QsciLexerCustom_AutoCompletionFillups(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_AutoCompletionFillups)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_AutoCompletionWordSeparators() []string {
+
+	var _ma C.struct_miqt_array = C.QsciLexerCustom_virtualbase_AutoCompletionWordSeparators(unsafe.Pointer(this.h))
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+
+}
+func (this *QsciLexerCustom) OnAutoCompletionWordSeparators(slot func(super func() []string) []string) {
+	C.QsciLexerCustom_override_virtual_AutoCompletionWordSeparators(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_AutoCompletionWordSeparators
+func miqt_exec_callback_QsciLexerCustom_AutoCompletionWordSeparators(self *C.QsciLexerCustom, cb C.intptr_t) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() []string) []string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_AutoCompletionWordSeparators)
+	virtualReturn_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_i_ms := C.struct_miqt_string{}
+		virtualReturn_i_ms.data = C.CString(virtualReturn[i])
+		virtualReturn_i_ms.len = C.size_t(len(virtualReturn[i]))
+		defer C.free(unsafe.Pointer(virtualReturn_i_ms.data))
+		virtualReturn_CArray[i] = virtualReturn_i_ms
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockEnd(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockEnd(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockEnd(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockEnd(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockEnd
+func miqt_exec_callback_QsciLexerCustom_BlockEnd(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockEnd, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockLookback() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_BlockLookback(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnBlockLookback(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_BlockLookback(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockLookback
+func miqt_exec_callback_QsciLexerCustom_BlockLookback(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockLookback)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockStart(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockStart(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockStart(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockStart(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockStart
+func miqt_exec_callback_QsciLexerCustom_BlockStart(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockStart, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BlockStartKeyword(style *int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_BlockStartKeyword(unsafe.Pointer(this.h), (*C.int)(unsafe.Pointer(style)))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnBlockStartKeyword(slot func(super func(style *int) string, style *int) string) {
+	C.QsciLexerCustom_override_virtual_BlockStartKeyword(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BlockStartKeyword
+func miqt_exec_callback_QsciLexerCustom_BlockStartKeyword(self *C.QsciLexerCustom, cb C.intptr_t, style *C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style *int) string, style *int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (*int)(unsafe.Pointer(style))
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BlockStartKeyword, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_BraceStyle() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_BraceStyle(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnBraceStyle(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_BraceStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_BraceStyle
+func miqt_exec_callback_QsciLexerCustom_BraceStyle(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_BraceStyle)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_CaseSensitive() bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_CaseSensitive(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnCaseSensitive(slot func(super func() bool) bool) {
+	C.QsciLexerCustom_override_virtual_CaseSensitive(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_CaseSensitive
+func miqt_exec_callback_QsciLexerCustom_CaseSensitive(self *C.QsciLexerCustom, cb C.intptr_t) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_CaseSensitive)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Color(style int) *qt6.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_Color(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnColor(slot func(super func(style int) *qt6.QColor, style int) *qt6.QColor) {
+	C.QsciLexerCustom_override_virtual_Color(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Color
+func miqt_exec_callback_QsciLexerCustom_Color(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QColor, style int) *qt6.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Color, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_EolFill(style int) bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_EolFill(unsafe.Pointer(this.h), (C.int)(style)))
+
+}
+func (this *QsciLexerCustom) OnEolFill(slot func(super func(style int) bool, style int) bool) {
+	C.QsciLexerCustom_override_virtual_EolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_EolFill
+func miqt_exec_callback_QsciLexerCustom_EolFill(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) bool, style int) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_EolFill, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Font(style int) *qt6.QFont {
+
+	_ret := C.QsciLexerCustom_virtualbase_Font(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQFont(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnFont(slot func(super func(style int) *qt6.QFont, style int) *qt6.QFont) {
+	C.QsciLexerCustom_override_virtual_Font(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Font
+func miqt_exec_callback_QsciLexerCustom_Font(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QFont {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QFont, style int) *qt6.QFont)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Font, slotval1)
+
+	return (*C.QFont)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_IndentationGuideView() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_IndentationGuideView(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnIndentationGuideView(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_IndentationGuideView(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_IndentationGuideView
+func miqt_exec_callback_QsciLexerCustom_IndentationGuideView(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_IndentationGuideView)
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Keywords(set int) string {
+
+	_ret := C.QsciLexerCustom_virtualbase_Keywords(unsafe.Pointer(this.h), (C.int)(set))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnKeywords(slot func(super func(set int) string, set int) string) {
+	C.QsciLexerCustom_override_virtual_Keywords(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Keywords
+func miqt_exec_callback_QsciLexerCustom_Keywords(self *C.QsciLexerCustom, cb C.intptr_t, set C.int) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(set int) string, set int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(set)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Keywords, slotval1)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultStyle() int {
+
+	return (int)(C.QsciLexerCustom_virtualbase_DefaultStyle(unsafe.Pointer(this.h)))
+
+}
+func (this *QsciLexerCustom) OnDefaultStyle(slot func(super func() int) int) {
+	C.QsciLexerCustom_override_virtual_DefaultStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultStyle(self *C.QsciLexerCustom, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultStyle)
+
+	return (C.int)(virtualReturn)
+
+}
+func (this *QsciLexerCustom) OnDescription(slot func(style int) string) {
+	C.QsciLexerCustom_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Description
+func miqt_exec_callback_QsciLexerCustom_Description(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.struct_miqt_string {
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc(slotval1)
+	virtualReturn_ms := C.struct_miqt_string{}
+	virtualReturn_ms.data = C.CString(virtualReturn)
+	virtualReturn_ms.len = C.size_t(len(virtualReturn))
+	defer C.free(unsafe.Pointer(virtualReturn_ms.data))
+
+	return virtualReturn_ms
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_Paper(style int) *qt6.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_Paper(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnPaper(slot func(super func(style int) *qt6.QColor, style int) *qt6.QColor) {
+	C.QsciLexerCustom_override_virtual_Paper(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_Paper
+func miqt_exec_callback_QsciLexerCustom_Paper(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QColor, style int) *qt6.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_Paper, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultColorWithStyle(style int) *qt6.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultColorWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultColorWithStyle(slot func(super func(style int) *qt6.QColor, style int) *qt6.QColor) {
+	C.QsciLexerCustom_override_virtual_DefaultColorWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultColorWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultColorWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QColor, style int) *qt6.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultColorWithStyle, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultEolFill(style int) bool {
+
+	return (bool)(C.QsciLexerCustom_virtualbase_DefaultEolFill(unsafe.Pointer(this.h), (C.int)(style)))
+
+}
+func (this *QsciLexerCustom) OnDefaultEolFill(slot func(super func(style int) bool, style int) bool) {
+	C.QsciLexerCustom_override_virtual_DefaultEolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultEolFill
+func miqt_exec_callback_QsciLexerCustom_DefaultEolFill(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) bool, style int) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultEolFill, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultFontWithStyle(style int) *qt6.QFont {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultFontWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQFont(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultFontWithStyle(slot func(super func(style int) *qt6.QFont, style int) *qt6.QFont) {
+	C.QsciLexerCustom_override_virtual_DefaultFontWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultFontWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultFontWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QFont {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QFont, style int) *qt6.QFont)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultFontWithStyle, slotval1)
+
+	return (*C.QFont)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_DefaultPaperWithStyle(style int) *qt6.QColor {
+
+	_ret := C.QsciLexerCustom_virtualbase_DefaultPaperWithStyle(unsafe.Pointer(this.h), (C.int)(style))
+	_goptr := qt6.UnsafeNewQColor(unsafe.Pointer(_ret))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QsciLexerCustom) OnDefaultPaperWithStyle(slot func(super func(style int) *qt6.QColor, style int) *qt6.QColor) {
+	C.QsciLexerCustom_override_virtual_DefaultPaperWithStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_DefaultPaperWithStyle
+func miqt_exec_callback_QsciLexerCustom_DefaultPaperWithStyle(self *C.QsciLexerCustom, cb C.intptr_t, style C.int) *C.QColor {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) *qt6.QColor, style int) *qt6.QColor)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(style)
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_DefaultPaperWithStyle, slotval1)
+
+	return (*C.QColor)(virtualReturn.UnsafePointer())
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_RefreshProperties() {
+
+	C.QsciLexerCustom_virtualbase_RefreshProperties(unsafe.Pointer(this.h))
+
+}
+func (this *QsciLexerCustom) OnRefreshProperties(slot func(super func())) {
+	C.QsciLexerCustom_override_virtual_RefreshProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_RefreshProperties
+func miqt_exec_callback_QsciLexerCustom_RefreshProperties(self *C.QsciLexerCustom, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_RefreshProperties)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_WordCharacters() string {
+
+	_ret := C.QsciLexerCustom_virtualbase_WordCharacters(unsafe.Pointer(this.h))
+	return C.GoString(_ret)
+
+}
+func (this *QsciLexerCustom) OnWordCharacters(slot func(super func() string) string) {
+	C.QsciLexerCustom_override_virtual_WordCharacters(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_WordCharacters
+func miqt_exec_callback_QsciLexerCustom_WordCharacters(self *C.QsciLexerCustom, cb C.intptr_t) *C.const_char {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_WordCharacters)
+	virtualReturn_Cstring := C.CString(virtualReturn)
+	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
+
+	return virtualReturn_Cstring
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetAutoIndentStyle(autoindentstyle int) {
+
+	C.QsciLexerCustom_virtualbase_SetAutoIndentStyle(unsafe.Pointer(this.h), (C.int)(autoindentstyle))
+
+}
+func (this *QsciLexerCustom) OnSetAutoIndentStyle(slot func(super func(autoindentstyle int), autoindentstyle int)) {
+	C.QsciLexerCustom_override_virtual_SetAutoIndentStyle(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetAutoIndentStyle
+func miqt_exec_callback_QsciLexerCustom_SetAutoIndentStyle(self *C.QsciLexerCustom, cb C.intptr_t, autoindentstyle C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(autoindentstyle int), autoindentstyle int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(autoindentstyle)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetAutoIndentStyle, slotval1)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetColor(c *qt6.QColor, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetColor(unsafe.Pointer(this.h), (*C.QColor)(c.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetColor(slot func(super func(c *qt6.QColor, style int), c *qt6.QColor, style int)) {
+	C.QsciLexerCustom_override_virtual_SetColor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetColor
+func miqt_exec_callback_QsciLexerCustom_SetColor(self *C.QsciLexerCustom, cb C.intptr_t, c *C.QColor, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(c *qt6.QColor, style int), c *qt6.QColor, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQColor(unsafe.Pointer(c))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetColor, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetEolFill(eoffill bool, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetEolFill(unsafe.Pointer(this.h), (C.bool)(eoffill), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetEolFill(slot func(super func(eoffill bool, style int), eoffill bool, style int)) {
+	C.QsciLexerCustom_override_virtual_SetEolFill(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetEolFill
+func miqt_exec_callback_QsciLexerCustom_SetEolFill(self *C.QsciLexerCustom, cb C.intptr_t, eoffill C.bool, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(eoffill bool, style int), eoffill bool, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(eoffill)
+
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetEolFill, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetFont(f *qt6.QFont, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetFont(unsafe.Pointer(this.h), (*C.QFont)(f.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetFont(slot func(super func(f *qt6.QFont, style int), f *qt6.QFont, style int)) {
+	C.QsciLexerCustom_override_virtual_SetFont(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetFont
+func miqt_exec_callback_QsciLexerCustom_SetFont(self *C.QsciLexerCustom, cb C.intptr_t, f *C.QFont, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(f *qt6.QFont, style int), f *qt6.QFont, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQFont(unsafe.Pointer(f))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetFont, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_SetPaper(c *qt6.QColor, style int) {
+
+	C.QsciLexerCustom_virtualbase_SetPaper(unsafe.Pointer(this.h), (*C.QColor)(c.UnsafePointer()), (C.int)(style))
+
+}
+func (this *QsciLexerCustom) OnSetPaper(slot func(super func(c *qt6.QColor, style int), c *qt6.QColor, style int)) {
+	C.QsciLexerCustom_override_virtual_SetPaper(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_SetPaper
+func miqt_exec_callback_QsciLexerCustom_SetPaper(self *C.QsciLexerCustom, cb C.intptr_t, c *C.QColor, style C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(c *qt6.QColor, style int), c *qt6.QColor, style int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQColor(unsafe.Pointer(c))
+	slotval2 := (int)(style)
+
+	gofunc((&QsciLexerCustom{h: self}).callVirtualBase_SetPaper, slotval1, slotval2)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_ReadProperties(qs *qt6.QSettings, prefix string) bool {
+	prefix_ms := C.struct_miqt_string{}
+	prefix_ms.data = C.CString(prefix)
+	prefix_ms.len = C.size_t(len(prefix))
+	defer C.free(unsafe.Pointer(prefix_ms.data))
+
+	return (bool)(C.QsciLexerCustom_virtualbase_ReadProperties(unsafe.Pointer(this.h), (*C.QSettings)(qs.UnsafePointer()), prefix_ms))
+
+}
+func (this *QsciLexerCustom) OnReadProperties(slot func(super func(qs *qt6.QSettings, prefix string) bool, qs *qt6.QSettings, prefix string) bool) {
+	C.QsciLexerCustom_override_virtual_ReadProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_ReadProperties
+func miqt_exec_callback_QsciLexerCustom_ReadProperties(self *C.QsciLexerCustom, cb C.intptr_t, qs *C.QSettings, prefix C.struct_miqt_string) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(qs *qt6.QSettings, prefix string) bool, qs *qt6.QSettings, prefix string) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQSettings(unsafe.Pointer(qs), nil)
+	var prefix_ms C.struct_miqt_string = prefix
+	prefix_ret := C.GoStringN(prefix_ms.data, C.int(int64(prefix_ms.len)))
+	C.free(unsafe.Pointer(prefix_ms.data))
+	slotval2 := prefix_ret
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_ReadProperties, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QsciLexerCustom) callVirtualBase_WriteProperties(qs *qt6.QSettings, prefix string) bool {
+	prefix_ms := C.struct_miqt_string{}
+	prefix_ms.data = C.CString(prefix)
+	prefix_ms.len = C.size_t(len(prefix))
+	defer C.free(unsafe.Pointer(prefix_ms.data))
+
+	return (bool)(C.QsciLexerCustom_virtualbase_WriteProperties(unsafe.Pointer(this.h), (*C.QSettings)(qs.UnsafePointer()), prefix_ms))
+
+}
+func (this *QsciLexerCustom) OnWriteProperties(slot func(super func(qs *qt6.QSettings, prefix string) bool, qs *qt6.QSettings, prefix string) bool) {
+	C.QsciLexerCustom_override_virtual_WriteProperties(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QsciLexerCustom_WriteProperties
+func miqt_exec_callback_QsciLexerCustom_WriteProperties(self *C.QsciLexerCustom, cb C.intptr_t, qs *C.QSettings, prefix C.struct_miqt_string) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(qs *qt6.QSettings, prefix string) bool, qs *qt6.QSettings, prefix string) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQSettings(unsafe.Pointer(qs), nil)
+	var prefix_ms C.struct_miqt_string = prefix
+	prefix_ret := C.GoStringN(prefix_ms.data, C.int(int64(prefix_ms.len)))
+	C.free(unsafe.Pointer(prefix_ms.data))
+	slotval2 := prefix_ret
+
+	virtualReturn := gofunc((&QsciLexerCustom{h: self}).callVirtualBase_WriteProperties, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QsciLexerCustom) Delete() {

qt-restricted-extras/qscintilla6/gen_qscilexercustom.h

@@ -15,21 +15,29 @@ extern "C" {
 #endif
 
 #ifdef __cplusplus
+class QColor;
+class QFont;
 class QMetaObject;
 class QObject;
+class QSettings;
 class QsciLexer;
 class QsciLexerCustom;
 class QsciScintilla;
 class QsciStyle;
 #else
+typedef struct QColor QColor;
+typedef struct QFont QFont;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
+typedef struct QSettings QSettings;
 typedef struct QsciLexer QsciLexer;
 typedef struct QsciLexerCustom QsciLexerCustom;
 typedef struct QsciScintilla QsciScintilla;
 typedef struct QsciStyle QsciStyle;
 #endif
 
+void QsciLexerCustom_new(QsciLexerCustom** outptr_QsciLexerCustom, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
+void QsciLexerCustom_new2(QObject* parent, QsciLexerCustom** outptr_QsciLexerCustom, QsciLexer** outptr_QsciLexer, QObject** outptr_QObject);
 QMetaObject* QsciLexerCustom_MetaObject(const QsciLexerCustom* self);
 void* QsciLexerCustom_Metacast(QsciLexerCustom* self, const char* param1);
 struct miqt_string QsciLexerCustom_Tr(const char* s);
@@ -42,6 +50,76 @@ int QsciLexerCustom_StyleBitsNeeded(const QsciLexerCustom* self);
 struct miqt_string QsciLexerCustom_Tr2(const char* s, const char* c);
 struct miqt_string QsciLexerCustom_Tr3(const char* s, const char* c, int n);
 void QsciLexerCustom_StartStyling2(QsciLexerCustom* self, int pos, int styleBits);
+void QsciLexerCustom_override_virtual_StyleText(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_StyleText(void* self, int start, int end);
+void QsciLexerCustom_override_virtual_SetEditor(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetEditor(void* self, QsciScintilla* editor);
+void QsciLexerCustom_override_virtual_StyleBitsNeeded(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_StyleBitsNeeded(const void* self);
+void QsciLexerCustom_override_virtual_Language(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Language(const void* self);
+void QsciLexerCustom_override_virtual_Lexer(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Lexer(const void* self);
+void QsciLexerCustom_override_virtual_LexerId(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_LexerId(const void* self);
+void QsciLexerCustom_override_virtual_AutoCompletionFillups(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_AutoCompletionFillups(const void* self);
+void QsciLexerCustom_override_virtual_AutoCompletionWordSeparators(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QsciLexerCustom_virtualbase_AutoCompletionWordSeparators(const void* self);
+void QsciLexerCustom_override_virtual_BlockEnd(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockEnd(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BlockLookback(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_BlockLookback(const void* self);
+void QsciLexerCustom_override_virtual_BlockStart(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockStart(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BlockStartKeyword(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_BlockStartKeyword(const void* self, int* style);
+void QsciLexerCustom_override_virtual_BraceStyle(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_BraceStyle(const void* self);
+void QsciLexerCustom_override_virtual_CaseSensitive(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_CaseSensitive(const void* self);
+void QsciLexerCustom_override_virtual_Color(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_Color(const void* self, int style);
+void QsciLexerCustom_override_virtual_EolFill(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_EolFill(const void* self, int style);
+void QsciLexerCustom_override_virtual_Font(void* self, intptr_t slot);
+QFont* QsciLexerCustom_virtualbase_Font(const void* self, int style);
+void QsciLexerCustom_override_virtual_IndentationGuideView(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_IndentationGuideView(const void* self);
+void QsciLexerCustom_override_virtual_Keywords(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_Keywords(const void* self, int set);
+void QsciLexerCustom_override_virtual_DefaultStyle(void* self, intptr_t slot);
+int QsciLexerCustom_virtualbase_DefaultStyle(const void* self);
+void QsciLexerCustom_override_virtual_Description(void* self, intptr_t slot);
+struct miqt_string QsciLexerCustom_virtualbase_Description(const void* self, int style);
+void QsciLexerCustom_override_virtual_Paper(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_Paper(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultColorWithStyle(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_DefaultColorWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultEolFill(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_DefaultEolFill(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultFontWithStyle(void* self, intptr_t slot);
+QFont* QsciLexerCustom_virtualbase_DefaultFontWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_DefaultPaperWithStyle(void* self, intptr_t slot);
+QColor* QsciLexerCustom_virtualbase_DefaultPaperWithStyle(const void* self, int style);
+void QsciLexerCustom_override_virtual_RefreshProperties(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_RefreshProperties(void* self);
+void QsciLexerCustom_override_virtual_WordCharacters(void* self, intptr_t slot);
+const char* QsciLexerCustom_virtualbase_WordCharacters(const void* self);
+void QsciLexerCustom_override_virtual_SetAutoIndentStyle(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetAutoIndentStyle(void* self, int autoindentstyle);
+void QsciLexerCustom_override_virtual_SetColor(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetColor(void* self, QColor* c, int style);
+void QsciLexerCustom_override_virtual_SetEolFill(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetEolFill(void* self, bool eoffill, int style);
+void QsciLexerCustom_override_virtual_SetFont(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetFont(void* self, QFont* f, int style);
+void QsciLexerCustom_override_virtual_SetPaper(void* self, intptr_t slot);
+void QsciLexerCustom_virtualbase_SetPaper(void* self, QColor* c, int style);
+void QsciLexerCustom_override_virtual_ReadProperties(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_ReadProperties(void* self, QSettings* qs, struct miqt_string prefix);
+void QsciLexerCustom_override_virtual_WriteProperties(void* self, intptr_t slot);
+bool QsciLexerCustom_virtualbase_WriteProperties(const void* self, QSettings* qs, struct miqt_string prefix);
 void QsciLexerCustom_Delete(QsciLexerCustom* self, bool isSubclass);
 
 #ifdef __cplusplus

qt-restricted-extras/qscintilla6/gen_qscilexerd.go

@@ -342,25 +342,18 @@ func miqt_exec_callback_QsciLexerD_SetFoldCompact(self *C.QsciLexerD, cb C.intpt
 	gofunc((&QsciLexerD{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerD) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerD_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerD) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerD) OnLanguage(slot func() string) {
 	C.QsciLexerD_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerD_Language
 func miqt_exec_callback_QsciLexerD_Language(self *C.QsciLexerD, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerD{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -783,21 +776,13 @@ func miqt_exec_callback_QsciLexerD_DefaultStyle(self *C.QsciLexerD, cb C.intptr_
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerD) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerD_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerD) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerD) OnDescription(slot func(style int) string) {
 	C.QsciLexerD_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerD_Description
 func miqt_exec_callback_QsciLexerD_Description(self *C.QsciLexerD, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -805,7 +790,7 @@ func miqt_exec_callback_QsciLexerD_Description(self *C.QsciLexerD, cb C.intptr_t
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerD{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerdiff.go

@@ -164,25 +164,18 @@ func QsciLexerDiff_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerDiff) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerDiff_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerDiff) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerDiff) OnLanguage(slot func() string) {
 	C.QsciLexerDiff_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerDiff_Language
 func miqt_exec_callback_QsciLexerDiff_Language(self *C.QsciLexerDiff, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerDiff{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -605,21 +598,13 @@ func miqt_exec_callback_QsciLexerDiff_DefaultStyle(self *C.QsciLexerDiff, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerDiff) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerDiff_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerDiff) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerDiff) OnDescription(slot func(style int) string) {
 	C.QsciLexerDiff_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerDiff_Description
 func miqt_exec_callback_QsciLexerDiff_Description(self *C.QsciLexerDiff, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -627,7 +612,7 @@ func miqt_exec_callback_QsciLexerDiff_Description(self *C.QsciLexerDiff, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerDiff{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexeredifact.go

@@ -156,25 +156,18 @@ func QsciLexerEDIFACT_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerEDIFACT) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerEDIFACT_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerEDIFACT) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerEDIFACT) OnLanguage(slot func() string) {
 	C.QsciLexerEDIFACT_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerEDIFACT_Language
 func miqt_exec_callback_QsciLexerEDIFACT_Language(self *C.QsciLexerEDIFACT, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerEDIFACT{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -597,21 +590,13 @@ func miqt_exec_callback_QsciLexerEDIFACT_DefaultStyle(self *C.QsciLexerEDIFACT,
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerEDIFACT) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerEDIFACT_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerEDIFACT) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerEDIFACT) OnDescription(slot func(style int) string) {
 	C.QsciLexerEDIFACT_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerEDIFACT_Description
 func miqt_exec_callback_QsciLexerEDIFACT_Description(self *C.QsciLexerEDIFACT, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -619,7 +604,7 @@ func miqt_exec_callback_QsciLexerEDIFACT_Description(self *C.QsciLexerEDIFACT, c
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerEDIFACT{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerfortran77.go

@@ -224,25 +224,18 @@ func miqt_exec_callback_QsciLexerFortran77_SetFoldCompact(self *C.QsciLexerFortr
 	gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerFortran77) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerFortran77_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerFortran77) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerFortran77) OnLanguage(slot func() string) {
 	C.QsciLexerFortran77_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerFortran77_Language
 func miqt_exec_callback_QsciLexerFortran77_Language(self *C.QsciLexerFortran77, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -665,21 +658,13 @@ func miqt_exec_callback_QsciLexerFortran77_DefaultStyle(self *C.QsciLexerFortran
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerFortran77) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerFortran77_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerFortran77) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerFortran77) OnDescription(slot func(style int) string) {
 	C.QsciLexerFortran77_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerFortran77_Description
 func miqt_exec_callback_QsciLexerFortran77_Description(self *C.QsciLexerFortran77, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -687,7 +672,7 @@ func miqt_exec_callback_QsciLexerFortran77_Description(self *C.QsciLexerFortran7
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerFortran77{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerhtml.go

@@ -419,25 +419,18 @@ func miqt_exec_callback_QsciLexerHTML_SetCaseSensitiveTags(self *C.QsciLexerHTML
 	gofunc((&QsciLexerHTML{h: self}).callVirtualBase_SetCaseSensitiveTags, slotval1)
 
 }
-
-func (this *QsciLexerHTML) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerHTML_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerHTML) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerHTML) OnLanguage(slot func() string) {
 	C.QsciLexerHTML_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerHTML_Language
 func miqt_exec_callback_QsciLexerHTML_Language(self *C.QsciLexerHTML, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerHTML{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -860,21 +853,13 @@ func miqt_exec_callback_QsciLexerHTML_DefaultStyle(self *C.QsciLexerHTML, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerHTML) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerHTML_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerHTML) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerHTML) OnDescription(slot func(style int) string) {
 	C.QsciLexerHTML_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerHTML_Description
 func miqt_exec_callback_QsciLexerHTML_Description(self *C.QsciLexerHTML, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -882,7 +867,7 @@ func miqt_exec_callback_QsciLexerHTML_Description(self *C.QsciLexerHTML, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerHTML{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerjson.go

@@ -212,25 +212,18 @@ func QsciLexerJSON_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerJSON) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerJSON_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerJSON) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerJSON) OnLanguage(slot func() string) {
 	C.QsciLexerJSON_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerJSON_Language
 func miqt_exec_callback_QsciLexerJSON_Language(self *C.QsciLexerJSON, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerJSON{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -653,21 +646,13 @@ func miqt_exec_callback_QsciLexerJSON_DefaultStyle(self *C.QsciLexerJSON, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerJSON) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerJSON_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerJSON) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerJSON) OnDescription(slot func(style int) string) {
 	C.QsciLexerJSON_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerJSON_Description
 func miqt_exec_callback_QsciLexerJSON_Description(self *C.QsciLexerJSON, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -675,7 +660,7 @@ func miqt_exec_callback_QsciLexerJSON_Description(self *C.QsciLexerJSON, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerJSON{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerlua.go

@@ -252,25 +252,18 @@ func miqt_exec_callback_QsciLexerLua_SetFoldCompact(self *C.QsciLexerLua, cb C.i
 	gofunc((&QsciLexerLua{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerLua) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerLua_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerLua) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerLua) OnLanguage(slot func() string) {
 	C.QsciLexerLua_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerLua_Language
 func miqt_exec_callback_QsciLexerLua_Language(self *C.QsciLexerLua, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerLua{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -693,21 +686,13 @@ func miqt_exec_callback_QsciLexerLua_DefaultStyle(self *C.QsciLexerLua, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerLua) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerLua_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerLua) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerLua) OnDescription(slot func(style int) string) {
 	C.QsciLexerLua_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerLua_Description
 func miqt_exec_callback_QsciLexerLua_Description(self *C.QsciLexerLua, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -715,7 +700,7 @@ func miqt_exec_callback_QsciLexerLua_Description(self *C.QsciLexerLua, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerLua{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexermakefile.go

@@ -177,25 +177,18 @@ func QsciLexerMakefile_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMakefile) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMakefile_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMakefile) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMakefile) OnLanguage(slot func() string) {
 	C.QsciLexerMakefile_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMakefile_Language
 func miqt_exec_callback_QsciLexerMakefile_Language(self *C.QsciLexerMakefile, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMakefile{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -618,21 +611,13 @@ func miqt_exec_callback_QsciLexerMakefile_DefaultStyle(self *C.QsciLexerMakefile
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMakefile) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMakefile_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMakefile) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMakefile) OnDescription(slot func(style int) string) {
 	C.QsciLexerMakefile_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMakefile_Description
 func miqt_exec_callback_QsciLexerMakefile_Description(self *C.QsciLexerMakefile, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -640,7 +625,7 @@ func miqt_exec_callback_QsciLexerMakefile_Description(self *C.QsciLexerMakefile,
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMakefile{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexermarkdown.go

@@ -183,25 +183,18 @@ func QsciLexerMarkdown_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMarkdown) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMarkdown_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMarkdown) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMarkdown) OnLanguage(slot func() string) {
 	C.QsciLexerMarkdown_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMarkdown_Language
 func miqt_exec_callback_QsciLexerMarkdown_Language(self *C.QsciLexerMarkdown, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMarkdown{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -624,21 +617,13 @@ func miqt_exec_callback_QsciLexerMarkdown_DefaultStyle(self *C.QsciLexerMarkdown
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMarkdown) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMarkdown_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMarkdown) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMarkdown) OnDescription(slot func(style int) string) {
 	C.QsciLexerMarkdown_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMarkdown_Description
 func miqt_exec_callback_QsciLexerMarkdown_Description(self *C.QsciLexerMarkdown, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -646,7 +631,7 @@ func miqt_exec_callback_QsciLexerMarkdown_Description(self *C.QsciLexerMarkdown,
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMarkdown{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexermatlab.go

@@ -168,25 +168,18 @@ func QsciLexerMatlab_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerMatlab) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerMatlab_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerMatlab) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerMatlab) OnLanguage(slot func() string) {
 	C.QsciLexerMatlab_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMatlab_Language
 func miqt_exec_callback_QsciLexerMatlab_Language(self *C.QsciLexerMatlab, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerMatlab{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -609,21 +602,13 @@ func miqt_exec_callback_QsciLexerMatlab_DefaultStyle(self *C.QsciLexerMatlab, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerMatlab) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerMatlab_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerMatlab) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerMatlab) OnDescription(slot func(style int) string) {
 	C.QsciLexerMatlab_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerMatlab_Description
 func miqt_exec_callback_QsciLexerMatlab_Description(self *C.QsciLexerMatlab, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -631,7 +616,7 @@ func miqt_exec_callback_QsciLexerMatlab_Description(self *C.QsciLexerMatlab, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerMatlab{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerpascal.go

@@ -337,25 +337,18 @@ func miqt_exec_callback_QsciLexerPascal_SetFoldPreprocessor(self *C.QsciLexerPas
 	gofunc((&QsciLexerPascal{h: self}).callVirtualBase_SetFoldPreprocessor, slotval1)
 
 }
-
-func (this *QsciLexerPascal) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPascal_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPascal) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPascal) OnLanguage(slot func() string) {
 	C.QsciLexerPascal_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPascal_Language
 func miqt_exec_callback_QsciLexerPascal_Language(self *C.QsciLexerPascal, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPascal{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -778,21 +771,13 @@ func miqt_exec_callback_QsciLexerPascal_DefaultStyle(self *C.QsciLexerPascal, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPascal) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPascal_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPascal) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPascal) OnDescription(slot func(style int) string) {
 	C.QsciLexerPascal_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPascal_Description
 func miqt_exec_callback_QsciLexerPascal_Description(self *C.QsciLexerPascal, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -800,7 +785,7 @@ func miqt_exec_callback_QsciLexerPascal_Description(self *C.QsciLexerPascal, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPascal{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerperl.go

@@ -343,25 +343,18 @@ func miqt_exec_callback_QsciLexerPerl_SetFoldCompact(self *C.QsciLexerPerl, cb C
 	gofunc((&QsciLexerPerl{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerPerl) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPerl_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPerl) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPerl) OnLanguage(slot func() string) {
 	C.QsciLexerPerl_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPerl_Language
 func miqt_exec_callback_QsciLexerPerl_Language(self *C.QsciLexerPerl, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPerl{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -784,21 +777,13 @@ func miqt_exec_callback_QsciLexerPerl_DefaultStyle(self *C.QsciLexerPerl, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPerl) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPerl_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPerl) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPerl) OnDescription(slot func(style int) string) {
 	C.QsciLexerPerl_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPerl_Description
 func miqt_exec_callback_QsciLexerPerl_Description(self *C.QsciLexerPerl, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -806,7 +791,7 @@ func miqt_exec_callback_QsciLexerPerl_Description(self *C.QsciLexerPerl, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPerl{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerpo.go

@@ -235,25 +235,18 @@ func miqt_exec_callback_QsciLexerPO_SetFoldCompact(self *C.QsciLexerPO, cb C.int
 	gofunc((&QsciLexerPO{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerPO) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPO_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPO) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPO) OnLanguage(slot func() string) {
 	C.QsciLexerPO_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPO_Language
 func miqt_exec_callback_QsciLexerPO_Language(self *C.QsciLexerPO, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPO{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -676,21 +669,13 @@ func miqt_exec_callback_QsciLexerPO_DefaultStyle(self *C.QsciLexerPO, cb C.intpt
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPO) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPO_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPO) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPO) OnDescription(slot func(style int) string) {
 	C.QsciLexerPO_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPO_Description
 func miqt_exec_callback_QsciLexerPO_Description(self *C.QsciLexerPO, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -698,7 +683,7 @@ func miqt_exec_callback_QsciLexerPO_Description(self *C.QsciLexerPO, cb C.intptr
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPO{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerpostscript.go

@@ -314,25 +314,18 @@ func miqt_exec_callback_QsciLexerPostScript_SetFoldAtElse(self *C.QsciLexerPostS
 	gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_SetFoldAtElse, slotval1)
 
 }
-
-func (this *QsciLexerPostScript) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPostScript_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPostScript) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPostScript) OnLanguage(slot func() string) {
 	C.QsciLexerPostScript_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPostScript_Language
 func miqt_exec_callback_QsciLexerPostScript_Language(self *C.QsciLexerPostScript, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -755,21 +748,13 @@ func miqt_exec_callback_QsciLexerPostScript_DefaultStyle(self *C.QsciLexerPostSc
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPostScript) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPostScript_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPostScript) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPostScript) OnDescription(slot func(style int) string) {
 	C.QsciLexerPostScript_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPostScript_Description
 func miqt_exec_callback_QsciLexerPostScript_Description(self *C.QsciLexerPostScript, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -777,7 +762,7 @@ func miqt_exec_callback_QsciLexerPostScript_Description(self *C.QsciLexerPostScr
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPostScript{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerpov.go

@@ -293,25 +293,18 @@ func miqt_exec_callback_QsciLexerPOV_SetFoldDirectives(self *C.QsciLexerPOV, cb
 	gofunc((&QsciLexerPOV{h: self}).callVirtualBase_SetFoldDirectives, slotval1)
 
 }
-
-func (this *QsciLexerPOV) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPOV_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPOV) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPOV) OnLanguage(slot func() string) {
 	C.QsciLexerPOV_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPOV_Language
 func miqt_exec_callback_QsciLexerPOV_Language(self *C.QsciLexerPOV, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPOV{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -734,21 +727,13 @@ func miqt_exec_callback_QsciLexerPOV_DefaultStyle(self *C.QsciLexerPOV, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPOV) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPOV_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPOV) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPOV) OnDescription(slot func(style int) string) {
 	C.QsciLexerPOV_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPOV_Description
 func miqt_exec_callback_QsciLexerPOV_Description(self *C.QsciLexerPOV, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -756,7 +741,7 @@ func miqt_exec_callback_QsciLexerPOV_Description(self *C.QsciLexerPOV, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPOV{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerproperties.go

@@ -219,25 +219,18 @@ func miqt_exec_callback_QsciLexerProperties_SetFoldCompact(self *C.QsciLexerProp
 	gofunc((&QsciLexerProperties{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerProperties) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerProperties_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerProperties) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerProperties) OnLanguage(slot func() string) {
 	C.QsciLexerProperties_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerProperties_Language
 func miqt_exec_callback_QsciLexerProperties_Language(self *C.QsciLexerProperties, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerProperties{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -660,21 +653,13 @@ func miqt_exec_callback_QsciLexerProperties_DefaultStyle(self *C.QsciLexerProper
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerProperties) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerProperties_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerProperties) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerProperties) OnDescription(slot func(style int) string) {
 	C.QsciLexerProperties_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerProperties_Description
 func miqt_exec_callback_QsciLexerProperties_Description(self *C.QsciLexerProperties, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -682,7 +667,7 @@ func miqt_exec_callback_QsciLexerProperties_Description(self *C.QsciLexerPropert
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerProperties{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerpython.go

@@ -402,25 +402,18 @@ func miqt_exec_callback_QsciLexerPython_SetIndentationWarning(self *C.QsciLexerP
 	gofunc((&QsciLexerPython{h: self}).callVirtualBase_SetIndentationWarning, slotval1)
 
 }
-
-func (this *QsciLexerPython) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerPython_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerPython) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerPython) OnLanguage(slot func() string) {
 	C.QsciLexerPython_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPython_Language
 func miqt_exec_callback_QsciLexerPython_Language(self *C.QsciLexerPython, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerPython{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -821,21 +814,13 @@ func miqt_exec_callback_QsciLexerPython_DefaultStyle(self *C.QsciLexerPython, cb
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerPython) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerPython_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerPython) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerPython) OnDescription(slot func(style int) string) {
 	C.QsciLexerPython_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerPython_Description
 func miqt_exec_callback_QsciLexerPython_Description(self *C.QsciLexerPython, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -843,7 +828,7 @@ func miqt_exec_callback_QsciLexerPython_Description(self *C.QsciLexerPython, cb
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerPython{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerruby.go

@@ -255,25 +255,18 @@ func (this *QsciLexerRuby) BlockStartKeyword1(style *int) string {
 	_ret := C.QsciLexerRuby_BlockStartKeyword1(this.h, (*C.int)(unsafe.Pointer(style)))
 	return C.GoString(_ret)
 }
-
-func (this *QsciLexerRuby) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerRuby_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerRuby) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerRuby) OnLanguage(slot func() string) {
 	C.QsciLexerRuby_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerRuby_Language
 func miqt_exec_callback_QsciLexerRuby_Language(self *C.QsciLexerRuby, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerRuby{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -696,21 +689,13 @@ func miqt_exec_callback_QsciLexerRuby_DefaultStyle(self *C.QsciLexerRuby, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerRuby) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerRuby_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerRuby) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerRuby) OnDescription(slot func(style int) string) {
 	C.QsciLexerRuby_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerRuby_Description
 func miqt_exec_callback_QsciLexerRuby_Description(self *C.QsciLexerRuby, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -718,7 +703,7 @@ func miqt_exec_callback_QsciLexerRuby_Description(self *C.QsciLexerRuby, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerRuby{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerspice.go

@@ -172,25 +172,18 @@ func QsciLexerSpice_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerSpice) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerSpice_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerSpice) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerSpice) OnLanguage(slot func() string) {
 	C.QsciLexerSpice_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSpice_Language
 func miqt_exec_callback_QsciLexerSpice_Language(self *C.QsciLexerSpice, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerSpice{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -613,21 +606,13 @@ func miqt_exec_callback_QsciLexerSpice_DefaultStyle(self *C.QsciLexerSpice, cb C
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerSpice) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerSpice_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerSpice) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerSpice) OnDescription(slot func(style int) string) {
 	C.QsciLexerSpice_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSpice_Description
 func miqt_exec_callback_QsciLexerSpice_Description(self *C.QsciLexerSpice, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -635,7 +620,7 @@ func miqt_exec_callback_QsciLexerSpice_Description(self *C.QsciLexerSpice, cb C.
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerSpice{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexersql.go

@@ -333,25 +333,18 @@ func miqt_exec_callback_QsciLexerSQL_SetFoldCompact(self *C.QsciLexerSQL, cb C.i
 	gofunc((&QsciLexerSQL{h: self}).callVirtualBase_SetFoldCompact, slotval1)
 
 }
-
-func (this *QsciLexerSQL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerSQL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerSQL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerSQL) OnLanguage(slot func() string) {
 	C.QsciLexerSQL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSQL_Language
 func miqt_exec_callback_QsciLexerSQL_Language(self *C.QsciLexerSQL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerSQL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -774,21 +767,13 @@ func miqt_exec_callback_QsciLexerSQL_DefaultStyle(self *C.QsciLexerSQL, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerSQL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerSQL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerSQL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerSQL) OnDescription(slot func(style int) string) {
 	C.QsciLexerSQL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerSQL_Description
 func miqt_exec_callback_QsciLexerSQL_Description(self *C.QsciLexerSQL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -796,7 +781,7 @@ func miqt_exec_callback_QsciLexerSQL_Description(self *C.QsciLexerSQL, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerSQL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexertcl.go

@@ -208,25 +208,18 @@ func QsciLexerTCL_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerTCL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerTCL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerTCL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerTCL) OnLanguage(slot func() string) {
 	C.QsciLexerTCL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTCL_Language
 func miqt_exec_callback_QsciLexerTCL_Language(self *C.QsciLexerTCL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerTCL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -649,21 +642,13 @@ func miqt_exec_callback_QsciLexerTCL_DefaultStyle(self *C.QsciLexerTCL, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerTCL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerTCL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerTCL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerTCL) OnDescription(slot func(style int) string) {
 	C.QsciLexerTCL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTCL_Description
 func miqt_exec_callback_QsciLexerTCL_Description(self *C.QsciLexerTCL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -671,7 +656,7 @@ func miqt_exec_callback_QsciLexerTCL_Description(self *C.QsciLexerTCL, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerTCL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexertex.go

@@ -199,25 +199,18 @@ func QsciLexerTeX_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerTeX) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerTeX_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerTeX) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerTeX) OnLanguage(slot func() string) {
 	C.QsciLexerTeX_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTeX_Language
 func miqt_exec_callback_QsciLexerTeX_Language(self *C.QsciLexerTeX, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerTeX{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -640,21 +633,13 @@ func miqt_exec_callback_QsciLexerTeX_DefaultStyle(self *C.QsciLexerTeX, cb C.int
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerTeX) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerTeX_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerTeX) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerTeX) OnDescription(slot func(style int) string) {
 	C.QsciLexerTeX_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerTeX_Description
 func miqt_exec_callback_QsciLexerTeX_Description(self *C.QsciLexerTeX, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -662,7 +647,7 @@ func miqt_exec_callback_QsciLexerTeX_Description(self *C.QsciLexerTeX, cb C.intp
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerTeX{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexerverilog.go

@@ -261,25 +261,18 @@ func QsciLexerVerilog_Tr3(s string, c string, n int) string {
 	C.free(unsafe.Pointer(_ms.data))
 	return _ret
 }
-
-func (this *QsciLexerVerilog) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerVerilog_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerVerilog) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerVerilog) OnLanguage(slot func() string) {
 	C.QsciLexerVerilog_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVerilog_Language
 func miqt_exec_callback_QsciLexerVerilog_Language(self *C.QsciLexerVerilog, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerVerilog{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -702,21 +695,13 @@ func miqt_exec_callback_QsciLexerVerilog_DefaultStyle(self *C.QsciLexerVerilog,
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerVerilog) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerVerilog_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerVerilog) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerVerilog) OnDescription(slot func(style int) string) {
 	C.QsciLexerVerilog_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVerilog_Description
 func miqt_exec_callback_QsciLexerVerilog_Description(self *C.QsciLexerVerilog, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -724,7 +709,7 @@ func miqt_exec_callback_QsciLexerVerilog_Description(self *C.QsciLexerVerilog, c
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerVerilog{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexervhdl.go

@@ -349,25 +349,18 @@ func miqt_exec_callback_QsciLexerVHDL_SetFoldAtParenthesis(self *C.QsciLexerVHDL
 	gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_SetFoldAtParenthesis, slotval1)
 
 }
-
-func (this *QsciLexerVHDL) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerVHDL_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerVHDL) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerVHDL) OnLanguage(slot func() string) {
 	C.QsciLexerVHDL_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVHDL_Language
 func miqt_exec_callback_QsciLexerVHDL_Language(self *C.QsciLexerVHDL, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -790,21 +783,13 @@ func miqt_exec_callback_QsciLexerVHDL_DefaultStyle(self *C.QsciLexerVHDL, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerVHDL) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerVHDL_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerVHDL) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerVHDL) OnDescription(slot func(style int) string) {
 	C.QsciLexerVHDL_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerVHDL_Description
 func miqt_exec_callback_QsciLexerVHDL_Description(self *C.QsciLexerVHDL, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -812,7 +797,7 @@ func miqt_exec_callback_QsciLexerVHDL_Description(self *C.QsciLexerVHDL, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerVHDL{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt-restricted-extras/qscintilla6/gen_qscilexeryaml.go

@@ -215,25 +215,18 @@ func miqt_exec_callback_QsciLexerYAML_SetFoldComments(self *C.QsciLexerYAML, cb
 	gofunc((&QsciLexerYAML{h: self}).callVirtualBase_SetFoldComments, slotval1)
 
 }
-
-func (this *QsciLexerYAML) callVirtualBase_Language() string {
-
-	_ret := C.QsciLexerYAML_virtualbase_Language(unsafe.Pointer(this.h))
-	return C.GoString(_ret)
-
-}
-func (this *QsciLexerYAML) OnLanguage(slot func(super func() string) string) {
+func (this *QsciLexerYAML) OnLanguage(slot func() string) {
 	C.QsciLexerYAML_override_virtual_Language(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerYAML_Language
 func miqt_exec_callback_QsciLexerYAML_Language(self *C.QsciLexerYAML, cb C.intptr_t) *C.const_char {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func() string) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func() string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
 
-	virtualReturn := gofunc((&QsciLexerYAML{h: self}).callVirtualBase_Language)
+	virtualReturn := gofunc()
 	virtualReturn_Cstring := C.CString(virtualReturn)
 	defer C.free(unsafe.Pointer(virtualReturn_Cstring))
 
@@ -656,21 +649,13 @@ func miqt_exec_callback_QsciLexerYAML_DefaultStyle(self *C.QsciLexerYAML, cb C.i
 	return (C.int)(virtualReturn)
 
 }
-
-func (this *QsciLexerYAML) callVirtualBase_Description(style int) string {
-
-	var _ms C.struct_miqt_string = C.QsciLexerYAML_virtualbase_Description(unsafe.Pointer(this.h), (C.int)(style))
-	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
-	C.free(unsafe.Pointer(_ms.data))
-	return _ret
-}
-func (this *QsciLexerYAML) OnDescription(slot func(super func(style int) string, style int) string) {
+func (this *QsciLexerYAML) OnDescription(slot func(style int) string) {
 	C.QsciLexerYAML_override_virtual_Description(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
 }
 
 //export miqt_exec_callback_QsciLexerYAML_Description
 func miqt_exec_callback_QsciLexerYAML_Description(self *C.QsciLexerYAML, cb C.intptr_t, style C.int) C.struct_miqt_string {
-	gofunc, ok := cgo.Handle(cb).Value().(func(super func(style int) string, style int) string)
+	gofunc, ok := cgo.Handle(cb).Value().(func(style int) string)
 	if !ok {
 		panic("miqt: callback of non-callback type (heap corruption?)")
 	}
@@ -678,7 +663,7 @@ func miqt_exec_callback_QsciLexerYAML_Description(self *C.QsciLexerYAML, cb C.in
 	// Convert all CABI parameters to Go parameters
 	slotval1 := (int)(style)
 
-	virtualReturn := gofunc((&QsciLexerYAML{h: self}).callVirtualBase_Description, slotval1)
+	virtualReturn := gofunc(slotval1)
 	virtualReturn_ms := C.struct_miqt_string{}
 	virtualReturn_ms.data = C.CString(virtualReturn)
 	virtualReturn_ms.len = C.size_t(len(virtualReturn))

qt/gen_qabstractanimation.cpp

@@ -14,6 +14,282 @@
 #include "gen_qabstractanimation.h"
 #include "_cgo_export.h"
 
+class MiqtVirtualQAbstractAnimation : public virtual QAbstractAnimation {
+public:
+
+	MiqtVirtualQAbstractAnimation(): QAbstractAnimation() {};
+	MiqtVirtualQAbstractAnimation(QObject* parent): QAbstractAnimation(parent) {};
+
+	virtual ~MiqtVirtualQAbstractAnimation() = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Duration = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual int duration() const override {
+		if (handle__Duration == 0) {
+			return 0; // Pure virtual, there is no base we can call
+		}
+		
+
+		int callback_return_value = miqt_exec_callback_QAbstractAnimation_Duration(const_cast<MiqtVirtualQAbstractAnimation*>(this), handle__Duration);
+
+		return static_cast<int>(callback_return_value);
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__Event == 0) {
+			return QAbstractAnimation::event(event);
+		}
+		
+		QEvent* sigval1 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractAnimation_Event(this, handle__Event, sigval1);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_Event(QEvent* event) {
+
+		return QAbstractAnimation::event(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateCurrentTime = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateCurrentTime(int currentTime) override {
+		if (handle__UpdateCurrentTime == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		int sigval1 = currentTime;
+
+		miqt_exec_callback_QAbstractAnimation_UpdateCurrentTime(this, handle__UpdateCurrentTime, sigval1);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateState = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) override {
+		if (handle__UpdateState == 0) {
+			QAbstractAnimation::updateState(newState, oldState);
+			return;
+		}
+		
+		QAbstractAnimation::State newState_ret = newState;
+		int sigval1 = static_cast<int>(newState_ret);
+		QAbstractAnimation::State oldState_ret = oldState;
+		int sigval2 = static_cast<int>(oldState_ret);
+
+		miqt_exec_callback_QAbstractAnimation_UpdateState(this, handle__UpdateState, sigval1, sigval2);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_UpdateState(int newState, int oldState) {
+
+		QAbstractAnimation::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateDirection = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateDirection(QAbstractAnimation::Direction direction) override {
+		if (handle__UpdateDirection == 0) {
+			QAbstractAnimation::updateDirection(direction);
+			return;
+		}
+		
+		QAbstractAnimation::Direction direction_ret = direction;
+		int sigval1 = static_cast<int>(direction_ret);
+
+		miqt_exec_callback_QAbstractAnimation_UpdateDirection(this, handle__UpdateDirection, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_UpdateDirection(int direction) {
+
+		QAbstractAnimation::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__EventFilter == 0) {
+			return QAbstractAnimation::eventFilter(watched, event);
+		}
+		
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractAnimation_EventFilter(this, handle__EventFilter, sigval1, sigval2);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
+
+		return QAbstractAnimation::eventFilter(watched, event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__TimerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__TimerEvent == 0) {
+			QAbstractAnimation::timerEvent(event);
+			return;
+		}
+		
+		QTimerEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractAnimation_TimerEvent(this, handle__TimerEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_TimerEvent(QTimerEvent* event) {
+
+		QAbstractAnimation::timerEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ChildEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__ChildEvent == 0) {
+			QAbstractAnimation::childEvent(event);
+			return;
+		}
+		
+		QChildEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractAnimation_ChildEvent(this, handle__ChildEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ChildEvent(QChildEvent* event) {
+
+		QAbstractAnimation::childEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CustomEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__CustomEvent == 0) {
+			QAbstractAnimation::customEvent(event);
+			return;
+		}
+		
+		QEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractAnimation_CustomEvent(this, handle__CustomEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_CustomEvent(QEvent* event) {
+
+		QAbstractAnimation::customEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ConnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__ConnectNotify == 0) {
+			QAbstractAnimation::connectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractAnimation_ConnectNotify(this, handle__ConnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ConnectNotify(QMetaMethod* signal) {
+
+		QAbstractAnimation::connectNotify(*signal);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DisconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__DisconnectNotify == 0) {
+			QAbstractAnimation::disconnectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractAnimation_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DisconnectNotify(QMetaMethod* signal) {
+
+		QAbstractAnimation::disconnectNotify(*signal);
+
+	}
+
+};
+
+void QAbstractAnimation_new(QAbstractAnimation** outptr_QAbstractAnimation, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractAnimation* ret = new MiqtVirtualQAbstractAnimation();
+	*outptr_QAbstractAnimation = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
+void QAbstractAnimation_new2(QObject* parent, QAbstractAnimation** outptr_QAbstractAnimation, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractAnimation* ret = new MiqtVirtualQAbstractAnimation(parent);
+	*outptr_QAbstractAnimation = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
 QMetaObject* QAbstractAnimation_MetaObject(const QAbstractAnimation* self) {
 	return (QMetaObject*) self->metaObject();
 }
@@ -95,7 +371,7 @@ void QAbstractAnimation_Finished(QAbstractAnimation* self) {
 }
 
 void QAbstractAnimation_connect_Finished(QAbstractAnimation* self, intptr_t slot) {
-	QAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), self, [=]() {
+	MiqtVirtualQAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), self, [=]() {
 		miqt_exec_callback_QAbstractAnimation_Finished(slot);
 	});
 }
@@ -105,7 +381,7 @@ void QAbstractAnimation_StateChanged(QAbstractAnimation* self, int newState, int
 }
 
 void QAbstractAnimation_connect_StateChanged(QAbstractAnimation* self, intptr_t slot) {
-	QAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), self, [=](QAbstractAnimation::State newState, QAbstractAnimation::State oldState) {
+	MiqtVirtualQAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), self, [=](QAbstractAnimation::State newState, QAbstractAnimation::State oldState) {
 		QAbstractAnimation::State newState_ret = newState;
 		int sigval1 = static_cast<int>(newState_ret);
 		QAbstractAnimation::State oldState_ret = oldState;
@@ -119,7 +395,7 @@ void QAbstractAnimation_CurrentLoopChanged(QAbstractAnimation* self, int current
 }
 
 void QAbstractAnimation_connect_CurrentLoopChanged(QAbstractAnimation* self, intptr_t slot) {
-	QAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), self, [=](int currentLoop) {
+	MiqtVirtualQAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), self, [=](int currentLoop) {
 		int sigval1 = currentLoop;
 		miqt_exec_callback_QAbstractAnimation_CurrentLoopChanged(slot, sigval1);
 	});
@@ -130,7 +406,7 @@ void QAbstractAnimation_DirectionChanged(QAbstractAnimation* self, int param1) {
 }
 
 void QAbstractAnimation_connect_DirectionChanged(QAbstractAnimation* self, intptr_t slot) {
-	QAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), self, [=](QAbstractAnimation::Direction param1) {
+	MiqtVirtualQAbstractAnimation::connect(self, static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), self, [=](QAbstractAnimation::Direction param1) {
 		QAbstractAnimation::Direction param1_ret = param1;
 		int sigval1 = static_cast<int>(param1_ret);
 		miqt_exec_callback_QAbstractAnimation_DirectionChanged(slot, sigval1);
@@ -209,9 +485,89 @@ void QAbstractAnimation_Start1(QAbstractAnimation* self, int policy) {
 	self->start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
 }
 
+void QAbstractAnimation_override_virtual_Duration(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__Duration = slot;
+}
+
+void QAbstractAnimation_override_virtual_Event(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__Event = slot;
+}
+
+bool QAbstractAnimation_virtualbase_Event(void* self, QEvent* event) {
+	return ( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_Event(event);
+}
+
+void QAbstractAnimation_override_virtual_UpdateCurrentTime(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__UpdateCurrentTime = slot;
+}
+
+void QAbstractAnimation_override_virtual_UpdateState(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__UpdateState = slot;
+}
+
+void QAbstractAnimation_virtualbase_UpdateState(void* self, int newState, int oldState) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_UpdateState(newState, oldState);
+}
+
+void QAbstractAnimation_override_virtual_UpdateDirection(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__UpdateDirection = slot;
+}
+
+void QAbstractAnimation_virtualbase_UpdateDirection(void* self, int direction) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_UpdateDirection(direction);
+}
+
+void QAbstractAnimation_override_virtual_EventFilter(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__EventFilter = slot;
+}
+
+bool QAbstractAnimation_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
+	return ( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_EventFilter(watched, event);
+}
+
+void QAbstractAnimation_override_virtual_TimerEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__TimerEvent = slot;
+}
+
+void QAbstractAnimation_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_TimerEvent(event);
+}
+
+void QAbstractAnimation_override_virtual_ChildEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__ChildEvent = slot;
+}
+
+void QAbstractAnimation_virtualbase_ChildEvent(void* self, QChildEvent* event) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_ChildEvent(event);
+}
+
+void QAbstractAnimation_override_virtual_CustomEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__CustomEvent = slot;
+}
+
+void QAbstractAnimation_virtualbase_CustomEvent(void* self, QEvent* event) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_CustomEvent(event);
+}
+
+void QAbstractAnimation_override_virtual_ConnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__ConnectNotify = slot;
+}
+
+void QAbstractAnimation_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_ConnectNotify(signal);
+}
+
+void QAbstractAnimation_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractAnimation*>( (QAbstractAnimation*)(self) )->handle__DisconnectNotify = slot;
+}
+
+void QAbstractAnimation_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractAnimation*)(self) )->virtualbase_DisconnectNotify(signal);
+}
+
 void QAbstractAnimation_Delete(QAbstractAnimation* self, bool isSubclass) {
 	if (isSubclass) {
-		delete dynamic_cast<QAbstractAnimation*>( self );
+		delete dynamic_cast<MiqtVirtualQAbstractAnimation*>( self );
 	} else {
 		delete self;
 	}

qt/gen_qabstractanimation.go

@@ -75,6 +75,28 @@ func UnsafeNewQAbstractAnimation(h unsafe.Pointer, h_QObject unsafe.Pointer) *QA
 		QObject: UnsafeNewQObject(h_QObject)}
 }
 
+// NewQAbstractAnimation constructs a new QAbstractAnimation object.
+func NewQAbstractAnimation() *QAbstractAnimation {
+	var outptr_QAbstractAnimation *C.QAbstractAnimation = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractAnimation_new(&outptr_QAbstractAnimation, &outptr_QObject)
+	ret := newQAbstractAnimation(outptr_QAbstractAnimation, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
+// NewQAbstractAnimation2 constructs a new QAbstractAnimation object.
+func NewQAbstractAnimation2(parent *QObject) *QAbstractAnimation {
+	var outptr_QAbstractAnimation *C.QAbstractAnimation = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractAnimation_new2(parent.cPointer(), &outptr_QAbstractAnimation, &outptr_QObject)
+	ret := newQAbstractAnimation(outptr_QAbstractAnimation, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QAbstractAnimation) MetaObject() *QMetaObject {
 	return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractAnimation_MetaObject(this.h)))
 }
@@ -297,6 +319,253 @@ func QAbstractAnimation_TrUtf83(s string, c string, n int) string {
 func (this *QAbstractAnimation) Start1(policy QAbstractAnimation__DeletionPolicy) {
 	C.QAbstractAnimation_Start1(this.h, (C.int)(policy))
 }
+func (this *QAbstractAnimation) OnDuration(slot func() int) {
+	C.QAbstractAnimation_override_virtual_Duration(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_Duration
+func miqt_exec_callback_QAbstractAnimation_Duration(self *C.QAbstractAnimation, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func() int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc()
+
+	return (C.int)(virtualReturn)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAbstractAnimation_virtualbase_Event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAbstractAnimation) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	C.QAbstractAnimation_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_Event
+func miqt_exec_callback_QAbstractAnimation_Event(self *C.QAbstractAnimation, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractAnimation{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAbstractAnimation) OnUpdateCurrentTime(slot func(currentTime int)) {
+	C.QAbstractAnimation_override_virtual_UpdateCurrentTime(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_UpdateCurrentTime
+func miqt_exec_callback_QAbstractAnimation_UpdateCurrentTime(self *C.QAbstractAnimation, cb C.intptr_t, currentTime C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(currentTime int))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(currentTime)
+
+	gofunc(slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
+
+	C.QAbstractAnimation_virtualbase_UpdateState(unsafe.Pointer(this.h), (C.int)(newState), (C.int)(oldState))
+
+}
+func (this *QAbstractAnimation) OnUpdateState(slot func(super func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State), newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
+	C.QAbstractAnimation_override_virtual_UpdateState(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_UpdateState
+func miqt_exec_callback_QAbstractAnimation_UpdateState(self *C.QAbstractAnimation, cb C.intptr_t, newState C.int, oldState C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State), newState QAbstractAnimation__State, oldState QAbstractAnimation__State))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (QAbstractAnimation__State)(newState)
+
+	slotval2 := (QAbstractAnimation__State)(oldState)
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_UpdateState, slotval1, slotval2)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_UpdateDirection(direction QAbstractAnimation__Direction) {
+
+	C.QAbstractAnimation_virtualbase_UpdateDirection(unsafe.Pointer(this.h), (C.int)(direction))
+
+}
+func (this *QAbstractAnimation) OnUpdateDirection(slot func(super func(direction QAbstractAnimation__Direction), direction QAbstractAnimation__Direction)) {
+	C.QAbstractAnimation_override_virtual_UpdateDirection(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_UpdateDirection
+func miqt_exec_callback_QAbstractAnimation_UpdateDirection(self *C.QAbstractAnimation, cb C.intptr_t, direction C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(direction QAbstractAnimation__Direction), direction QAbstractAnimation__Direction))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (QAbstractAnimation__Direction)(direction)
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_UpdateDirection, slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAbstractAnimation_virtualbase_EventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAbstractAnimation) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	C.QAbstractAnimation_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_EventFilter
+func miqt_exec_callback_QAbstractAnimation_EventFilter(self *C.QAbstractAnimation, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQObject(unsafe.Pointer(watched))
+	slotval2 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractAnimation{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAbstractAnimation_virtualbase_TimerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractAnimation) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	C.QAbstractAnimation_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_TimerEvent
+func miqt_exec_callback_QAbstractAnimation_TimerEvent(self *C.QAbstractAnimation, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAbstractAnimation_virtualbase_ChildEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractAnimation) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	C.QAbstractAnimation_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_ChildEvent
+func miqt_exec_callback_QAbstractAnimation_ChildEvent(self *C.QAbstractAnimation, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAbstractAnimation_virtualbase_CustomEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractAnimation) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	C.QAbstractAnimation_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_CustomEvent
+func miqt_exec_callback_QAbstractAnimation_CustomEvent(self *C.QAbstractAnimation, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractAnimation_virtualbase_ConnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractAnimation) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractAnimation_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_ConnectNotify
+func miqt_exec_callback_QAbstractAnimation_ConnectNotify(self *C.QAbstractAnimation, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAbstractAnimation) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractAnimation_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractAnimation) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractAnimation_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractAnimation_DisconnectNotify
+func miqt_exec_callback_QAbstractAnimation_DisconnectNotify(self *C.QAbstractAnimation, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractAnimation{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QAbstractAnimation) Delete() {

qt/gen_qabstractanimation.h

@@ -36,6 +36,8 @@ typedef struct QObject QObject;
 typedef struct QTimerEvent QTimerEvent;
 #endif
 
+void QAbstractAnimation_new(QAbstractAnimation** outptr_QAbstractAnimation, QObject** outptr_QObject);
+void QAbstractAnimation_new2(QObject* parent, QAbstractAnimation** outptr_QAbstractAnimation, QObject** outptr_QObject);
 QMetaObject* QAbstractAnimation_MetaObject(const QAbstractAnimation* self);
 void* QAbstractAnimation_Metacast(QAbstractAnimation* self, const char* param1);
 struct miqt_string QAbstractAnimation_Tr(const char* s);
@@ -74,6 +76,28 @@ struct miqt_string QAbstractAnimation_Tr3(const char* s, const char* c, int n);
 struct miqt_string QAbstractAnimation_TrUtf82(const char* s, const char* c);
 struct miqt_string QAbstractAnimation_TrUtf83(const char* s, const char* c, int n);
 void QAbstractAnimation_Start1(QAbstractAnimation* self, int policy);
+void QAbstractAnimation_override_virtual_Duration(void* self, intptr_t slot);
+int QAbstractAnimation_virtualbase_Duration(const void* self);
+void QAbstractAnimation_override_virtual_Event(void* self, intptr_t slot);
+bool QAbstractAnimation_virtualbase_Event(void* self, QEvent* event);
+void QAbstractAnimation_override_virtual_UpdateCurrentTime(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_UpdateCurrentTime(void* self, int currentTime);
+void QAbstractAnimation_override_virtual_UpdateState(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_UpdateState(void* self, int newState, int oldState);
+void QAbstractAnimation_override_virtual_UpdateDirection(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_UpdateDirection(void* self, int direction);
+void QAbstractAnimation_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QAbstractAnimation_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QAbstractAnimation_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QAbstractAnimation_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QAbstractAnimation_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_CustomEvent(void* self, QEvent* event);
+void QAbstractAnimation_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QAbstractAnimation_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QAbstractAnimation_Delete(QAbstractAnimation* self, bool isSubclass);
 
 void QAnimationDriver_new(QAnimationDriver** outptr_QAnimationDriver, QObject** outptr_QObject);

qt/gen_qabstractbutton.h

@@ -16,40 +16,78 @@ extern "C" {
 
 #ifdef __cplusplus
 class QAbstractButton;
+class QActionEvent;
 class QButtonGroup;
+class QByteArray;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
 class QEvent;
 class QFocusEvent;
+class QHideEvent;
 class QIcon;
+class QInputMethodEvent;
 class QKeyEvent;
 class QKeySequence;
 class QMetaObject;
 class QMouseEvent;
+class QMoveEvent;
 class QObject;
 class QPaintDevice;
+class QPaintEngine;
 class QPaintEvent;
+class QPainter;
 class QPoint;
+class QResizeEvent;
+class QShowEvent;
 class QSize;
+class QTabletEvent;
 class QTimerEvent;
+class QVariant;
+class QWheelEvent;
 class QWidget;
 #else
 typedef struct QAbstractButton QAbstractButton;
+typedef struct QActionEvent QActionEvent;
 typedef struct QButtonGroup QButtonGroup;
+typedef struct QByteArray QByteArray;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
 typedef struct QEvent QEvent;
 typedef struct QFocusEvent QFocusEvent;
+typedef struct QHideEvent QHideEvent;
 typedef struct QIcon QIcon;
+typedef struct QInputMethodEvent QInputMethodEvent;
 typedef struct QKeyEvent QKeyEvent;
 typedef struct QKeySequence QKeySequence;
 typedef struct QMetaObject QMetaObject;
 typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
 typedef struct QObject QObject;
 typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
 typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
 typedef struct QPoint QPoint;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QShowEvent QShowEvent;
 typedef struct QSize QSize;
+typedef struct QTabletEvent QTabletEvent;
 typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
 typedef struct QWidget QWidget;
 #endif
 
+void QAbstractButton_new(QWidget* parent, QAbstractButton** outptr_QAbstractButton, QWidget** outptr_QWidget, QObject** outptr_QObject, QPaintDevice** outptr_QPaintDevice);
+void QAbstractButton_new2(QAbstractButton** outptr_QAbstractButton, QWidget** outptr_QWidget, QObject** outptr_QObject, QPaintDevice** outptr_QPaintDevice);
 QMetaObject* QAbstractButton_MetaObject(const QAbstractButton* self);
 void* QAbstractButton_Metacast(QAbstractButton* self, const char* param1);
 struct miqt_string QAbstractButton_Tr(const char* s);
@@ -109,6 +147,96 @@ struct miqt_string QAbstractButton_TrUtf83(const char* s, const char* c, int n);
 void QAbstractButton_AnimateClick1(QAbstractButton* self, int msec);
 void QAbstractButton_Clicked1(QAbstractButton* self, bool checked);
 void QAbstractButton_connect_Clicked1(QAbstractButton* self, intptr_t slot);
+void QAbstractButton_override_virtual_PaintEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_PaintEvent(void* self, QPaintEvent* e);
+void QAbstractButton_override_virtual_HitButton(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_HitButton(const void* self, QPoint* pos);
+void QAbstractButton_override_virtual_CheckStateSet(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_CheckStateSet(void* self);
+void QAbstractButton_override_virtual_NextCheckState(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_NextCheckState(void* self);
+void QAbstractButton_override_virtual_Event(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_Event(void* self, QEvent* e);
+void QAbstractButton_override_virtual_KeyPressEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_KeyPressEvent(void* self, QKeyEvent* e);
+void QAbstractButton_override_virtual_KeyReleaseEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_KeyReleaseEvent(void* self, QKeyEvent* e);
+void QAbstractButton_override_virtual_MousePressEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_MousePressEvent(void* self, QMouseEvent* e);
+void QAbstractButton_override_virtual_MouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_MouseReleaseEvent(void* self, QMouseEvent* e);
+void QAbstractButton_override_virtual_MouseMoveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_MouseMoveEvent(void* self, QMouseEvent* e);
+void QAbstractButton_override_virtual_FocusInEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_FocusInEvent(void* self, QFocusEvent* e);
+void QAbstractButton_override_virtual_FocusOutEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_FocusOutEvent(void* self, QFocusEvent* e);
+void QAbstractButton_override_virtual_ChangeEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_ChangeEvent(void* self, QEvent* e);
+void QAbstractButton_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_TimerEvent(void* self, QTimerEvent* e);
+void QAbstractButton_override_virtual_DevType(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_DevType(const void* self);
+void QAbstractButton_override_virtual_SetVisible(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_SetVisible(void* self, bool visible);
+void QAbstractButton_override_virtual_SizeHint(void* self, intptr_t slot);
+QSize* QAbstractButton_virtualbase_SizeHint(const void* self);
+void QAbstractButton_override_virtual_MinimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractButton_virtualbase_MinimumSizeHint(const void* self);
+void QAbstractButton_override_virtual_HeightForWidth(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_HeightForWidth(const void* self, int param1);
+void QAbstractButton_override_virtual_HasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_HasHeightForWidth(const void* self);
+void QAbstractButton_override_virtual_PaintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractButton_virtualbase_PaintEngine(const void* self);
+void QAbstractButton_override_virtual_MouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_MouseDoubleClickEvent(void* self, QMouseEvent* event);
+void QAbstractButton_override_virtual_WheelEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_WheelEvent(void* self, QWheelEvent* event);
+void QAbstractButton_override_virtual_EnterEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_EnterEvent(void* self, QEvent* event);
+void QAbstractButton_override_virtual_LeaveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_LeaveEvent(void* self, QEvent* event);
+void QAbstractButton_override_virtual_MoveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_MoveEvent(void* self, QMoveEvent* event);
+void QAbstractButton_override_virtual_ResizeEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_ResizeEvent(void* self, QResizeEvent* event);
+void QAbstractButton_override_virtual_CloseEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_CloseEvent(void* self, QCloseEvent* event);
+void QAbstractButton_override_virtual_ContextMenuEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_ContextMenuEvent(void* self, QContextMenuEvent* event);
+void QAbstractButton_override_virtual_TabletEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_TabletEvent(void* self, QTabletEvent* event);
+void QAbstractButton_override_virtual_ActionEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_ActionEvent(void* self, QActionEvent* event);
+void QAbstractButton_override_virtual_DragEnterEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_DragEnterEvent(void* self, QDragEnterEvent* event);
+void QAbstractButton_override_virtual_DragMoveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_DragMoveEvent(void* self, QDragMoveEvent* event);
+void QAbstractButton_override_virtual_DragLeaveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_DragLeaveEvent(void* self, QDragLeaveEvent* event);
+void QAbstractButton_override_virtual_DropEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_DropEvent(void* self, QDropEvent* event);
+void QAbstractButton_override_virtual_ShowEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_ShowEvent(void* self, QShowEvent* event);
+void QAbstractButton_override_virtual_HideEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_HideEvent(void* self, QHideEvent* event);
+void QAbstractButton_override_virtual_NativeEvent(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_NativeEvent(void* self, struct miqt_string eventType, void* message, long* result);
+void QAbstractButton_override_virtual_Metric(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_Metric(const void* self, int param1);
+void QAbstractButton_override_virtual_InitPainter(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_InitPainter(const void* self, QPainter* painter);
+void QAbstractButton_override_virtual_Redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractButton_virtualbase_Redirected(const void* self, QPoint* offset);
+void QAbstractButton_override_virtual_SharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractButton_virtualbase_SharedPainter(const void* self);
+void QAbstractButton_override_virtual_InputMethodEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_InputMethodEvent(void* self, QInputMethodEvent* param1);
+void QAbstractButton_override_virtual_InputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractButton_virtualbase_InputMethodQuery(const void* self, int param1);
+void QAbstractButton_override_virtual_FocusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_FocusNextPrevChild(void* self, bool next);
 void QAbstractButton_Delete(QAbstractButton* self, bool isSubclass);
 
 #ifdef __cplusplus

qt/gen_qabstracteventdispatcher.cpp

@@ -2,7 +2,10 @@
 #define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo
 #include <QAbstractNativeEventFilter>
 #include <QByteArray>
+#include <QChildEvent>
+#include <QEvent>
 #include <QList>
+#include <QMetaMethod>
 #include <QMetaObject>
 #include <QObject>
 #include <QSocketNotifier>
@@ -10,10 +13,449 @@
 #include <QByteArray>
 #include <cstring>
 #include <QThread>
+#include <QTimerEvent>
 #include <qabstracteventdispatcher.h>
 #include "gen_qabstracteventdispatcher.h"
 #include "_cgo_export.h"
 
+class MiqtVirtualQAbstractEventDispatcher : public virtual QAbstractEventDispatcher {
+public:
+
+	MiqtVirtualQAbstractEventDispatcher(): QAbstractEventDispatcher() {};
+	MiqtVirtualQAbstractEventDispatcher(QObject* parent): QAbstractEventDispatcher(parent) {};
+
+	virtual ~MiqtVirtualQAbstractEventDispatcher() = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ProcessEvents = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) override {
+		if (handle__ProcessEvents == 0) {
+			return false; // Pure virtual, there is no base we can call
+		}
+		
+		QEventLoop::ProcessEventsFlags flags_ret = flags;
+		int sigval1 = static_cast<int>(flags_ret);
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(this, handle__ProcessEvents, sigval1);
+
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__HasPendingEvents = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool hasPendingEvents() override {
+		if (handle__HasPendingEvents == 0) {
+			return false; // Pure virtual, there is no base we can call
+		}
+		
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents(this, handle__HasPendingEvents);
+
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__RegisterSocketNotifier = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void registerSocketNotifier(QSocketNotifier* notifier) override {
+		if (handle__RegisterSocketNotifier == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		QSocketNotifier* sigval1 = notifier;
+
+		miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(this, handle__RegisterSocketNotifier, sigval1);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UnregisterSocketNotifier = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void unregisterSocketNotifier(QSocketNotifier* notifier) override {
+		if (handle__UnregisterSocketNotifier == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		QSocketNotifier* sigval1 = notifier;
+
+		miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(this, handle__UnregisterSocketNotifier, sigval1);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__RegisterTimer2 = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject* object) override {
+		if (handle__RegisterTimer2 == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		int sigval1 = timerId;
+		int sigval2 = interval;
+		Qt::TimerType timerType_ret = timerType;
+		int sigval3 = static_cast<int>(timerType_ret);
+		QObject* sigval4 = object;
+
+		miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(this, handle__RegisterTimer2, sigval1, sigval2, sigval3, sigval4);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UnregisterTimer = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool unregisterTimer(int timerId) override {
+		if (handle__UnregisterTimer == 0) {
+			return false; // Pure virtual, there is no base we can call
+		}
+		
+		int sigval1 = timerId;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(this, handle__UnregisterTimer, sigval1);
+
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UnregisterTimers = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool unregisterTimers(QObject* object) override {
+		if (handle__UnregisterTimers == 0) {
+			return false; // Pure virtual, there is no base we can call
+		}
+		
+		QObject* sigval1 = object;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(this, handle__UnregisterTimers, sigval1);
+
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__RegisteredTimers = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QList<QAbstractEventDispatcher::TimerInfo> registeredTimers(QObject* object) const override {
+		if (handle__RegisteredTimers == 0) {
+			return QList<QAbstractEventDispatcher::TimerInfo>(); // Pure virtual, there is no base we can call
+		}
+		
+		QObject* sigval1 = object;
+
+		struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */  callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(const_cast<MiqtVirtualQAbstractEventDispatcher*>(this), handle__RegisteredTimers, sigval1);
+		QList<QAbstractEventDispatcher::TimerInfo> callback_return_value_QList;
+		callback_return_value_QList.reserve(callback_return_value.len);
+		QAbstractEventDispatcher__TimerInfo** callback_return_value_arr = static_cast<QAbstractEventDispatcher__TimerInfo**>(callback_return_value.data);
+		for(size_t i = 0; i < callback_return_value.len; ++i) {
+			callback_return_value_QList.push_back(*(callback_return_value_arr[i]));
+		}
+
+		return callback_return_value_QList;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__RemainingTime = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual int remainingTime(int timerId) override {
+		if (handle__RemainingTime == 0) {
+			return 0; // Pure virtual, there is no base we can call
+		}
+		
+		int sigval1 = timerId;
+
+		int callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(this, handle__RemainingTime, sigval1);
+
+		return static_cast<int>(callback_return_value);
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__WakeUp = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void wakeUp() override {
+		if (handle__WakeUp == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+
+		miqt_exec_callback_QAbstractEventDispatcher_WakeUp(this, handle__WakeUp);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Interrupt = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void interrupt() override {
+		if (handle__Interrupt == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+
+		miqt_exec_callback_QAbstractEventDispatcher_Interrupt(this, handle__Interrupt);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Flush = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void flush() override {
+		if (handle__Flush == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+
+		miqt_exec_callback_QAbstractEventDispatcher_Flush(this, handle__Flush);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__StartingUp = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void startingUp() override {
+		if (handle__StartingUp == 0) {
+			QAbstractEventDispatcher::startingUp();
+			return;
+		}
+		
+
+		miqt_exec_callback_QAbstractEventDispatcher_StartingUp(this, handle__StartingUp);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_StartingUp() {
+
+		QAbstractEventDispatcher::startingUp();
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ClosingDown = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void closingDown() override {
+		if (handle__ClosingDown == 0) {
+			QAbstractEventDispatcher::closingDown();
+			return;
+		}
+		
+
+		miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(this, handle__ClosingDown);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ClosingDown() {
+
+		QAbstractEventDispatcher::closingDown();
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__Event == 0) {
+			return QAbstractEventDispatcher::event(event);
+		}
+		
+		QEvent* sigval1 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_Event(this, handle__Event, sigval1);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_Event(QEvent* event) {
+
+		return QAbstractEventDispatcher::event(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__EventFilter == 0) {
+			return QAbstractEventDispatcher::eventFilter(watched, event);
+		}
+		
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractEventDispatcher_EventFilter(this, handle__EventFilter, sigval1, sigval2);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
+
+		return QAbstractEventDispatcher::eventFilter(watched, event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__TimerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__TimerEvent == 0) {
+			QAbstractEventDispatcher::timerEvent(event);
+			return;
+		}
+		
+		QTimerEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(this, handle__TimerEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_TimerEvent(QTimerEvent* event) {
+
+		QAbstractEventDispatcher::timerEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ChildEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__ChildEvent == 0) {
+			QAbstractEventDispatcher::childEvent(event);
+			return;
+		}
+		
+		QChildEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(this, handle__ChildEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ChildEvent(QChildEvent* event) {
+
+		QAbstractEventDispatcher::childEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CustomEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__CustomEvent == 0) {
+			QAbstractEventDispatcher::customEvent(event);
+			return;
+		}
+		
+		QEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(this, handle__CustomEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_CustomEvent(QEvent* event) {
+
+		QAbstractEventDispatcher::customEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ConnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__ConnectNotify == 0) {
+			QAbstractEventDispatcher::connectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(this, handle__ConnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ConnectNotify(QMetaMethod* signal) {
+
+		QAbstractEventDispatcher::connectNotify(*signal);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DisconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__DisconnectNotify == 0) {
+			QAbstractEventDispatcher::disconnectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DisconnectNotify(QMetaMethod* signal) {
+
+		QAbstractEventDispatcher::disconnectNotify(*signal);
+
+	}
+
+};
+
+void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher();
+	*outptr_QAbstractEventDispatcher = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
+void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractEventDispatcher* ret = new MiqtVirtualQAbstractEventDispatcher(parent);
+	*outptr_QAbstractEventDispatcher = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
 QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self) {
 	return (QMetaObject*) self->metaObject();
 }
@@ -135,7 +577,7 @@ void QAbstractEventDispatcher_AboutToBlock(QAbstractEventDispatcher* self) {
 }
 
 void QAbstractEventDispatcher_connect_AboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) {
-	QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() {
+	MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() {
 		miqt_exec_callback_QAbstractEventDispatcher_AboutToBlock(slot);
 	});
 }
@@ -145,7 +587,7 @@ void QAbstractEventDispatcher_Awake(QAbstractEventDispatcher* self) {
 }
 
 void QAbstractEventDispatcher_connect_Awake(QAbstractEventDispatcher* self, intptr_t slot) {
-	QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() {
+	MiqtVirtualQAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() {
 		miqt_exec_callback_QAbstractEventDispatcher_Awake(slot);
 	});
 }
@@ -198,9 +640,129 @@ QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread) {
 	return QAbstractEventDispatcher::instance(thread);
 }
 
+void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ProcessEvents = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_HasPendingEvents(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__HasPendingEvents = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterSocketNotifier = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterSocketNotifier = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisterTimer2 = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimer = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__UnregisterTimers = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RegisteredTimers = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__RemainingTime = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__WakeUp = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Interrupt = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_Flush(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Flush = slot;
+}
+
+void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__StartingUp = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_StartingUp(void* self) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_StartingUp();
+}
+
+void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ClosingDown = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ClosingDown();
+}
+
+void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__Event = slot;
+}
+
+bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event) {
+	return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_Event(event);
+}
+
+void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__EventFilter = slot;
+}
+
+bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
+	return ( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_EventFilter(watched, event);
+}
+
+void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__TimerEvent = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_TimerEvent(event);
+}
+
+void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ChildEvent = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ChildEvent(event);
+}
+
+void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__CustomEvent = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_CustomEvent(event);
+}
+
+void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__ConnectNotify = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_ConnectNotify(signal);
+}
+
+void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( (QAbstractEventDispatcher*)(self) )->handle__DisconnectNotify = slot;
+}
+
+void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractEventDispatcher*)(self) )->virtualbase_DisconnectNotify(signal);
+}
+
 void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass) {
 	if (isSubclass) {
-		delete dynamic_cast<QAbstractEventDispatcher*>( self );
+		delete dynamic_cast<MiqtVirtualQAbstractEventDispatcher*>( self );
 	} else {
 		delete self;
 	}

qt/gen_qabstracteventdispatcher.go

@@ -53,6 +53,28 @@ func UnsafeNewQAbstractEventDispatcher(h unsafe.Pointer, h_QObject unsafe.Pointe
 		QObject: UnsafeNewQObject(h_QObject)}
 }
 
+// NewQAbstractEventDispatcher constructs a new QAbstractEventDispatcher object.
+func NewQAbstractEventDispatcher() *QAbstractEventDispatcher {
+	var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractEventDispatcher_new(&outptr_QAbstractEventDispatcher, &outptr_QObject)
+	ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
+// NewQAbstractEventDispatcher2 constructs a new QAbstractEventDispatcher object.
+func NewQAbstractEventDispatcher2(parent *QObject) *QAbstractEventDispatcher {
+	var outptr_QAbstractEventDispatcher *C.QAbstractEventDispatcher = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractEventDispatcher_new2(parent.cPointer(), &outptr_QAbstractEventDispatcher, &outptr_QObject)
+	ret := newQAbstractEventDispatcher(outptr_QAbstractEventDispatcher, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject {
 	return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractEventDispatcher_MetaObject(this.h)))
 }
@@ -250,6 +272,428 @@ func QAbstractEventDispatcher_TrUtf83(s string, c string, n int) string {
 func QAbstractEventDispatcher_Instance1(thread *QThread) *QAbstractEventDispatcher {
 	return UnsafeNewQAbstractEventDispatcher(unsafe.Pointer(C.QAbstractEventDispatcher_Instance1(thread.cPointer())), nil)
 }
+func (this *QAbstractEventDispatcher) OnProcessEvents(slot func(flags QEventLoop__ProcessEventsFlag) bool) {
+	C.QAbstractEventDispatcher_override_virtual_ProcessEvents(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents
+func miqt_exec_callback_QAbstractEventDispatcher_ProcessEvents(self *C.QAbstractEventDispatcher, cb C.intptr_t, flags C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(flags QEventLoop__ProcessEventsFlag) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (QEventLoop__ProcessEventsFlag)(flags)
+
+	virtualReturn := gofunc(slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAbstractEventDispatcher) OnHasPendingEvents(slot func() bool) {
+	C.QAbstractEventDispatcher_override_virtual_HasPendingEvents(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents
+func miqt_exec_callback_QAbstractEventDispatcher_HasPendingEvents(self *C.QAbstractEventDispatcher, cb C.intptr_t) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func() bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc()
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAbstractEventDispatcher) OnRegisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
+	C.QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier
+func miqt_exec_callback_QAbstractEventDispatcher_RegisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
+
+	gofunc(slotval1)
+
+}
+func (this *QAbstractEventDispatcher) OnUnregisterSocketNotifier(slot func(notifier *QSocketNotifier)) {
+	C.QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier
+func miqt_exec_callback_QAbstractEventDispatcher_UnregisterSocketNotifier(self *C.QAbstractEventDispatcher, cb C.intptr_t, notifier *C.QSocketNotifier) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(notifier *QSocketNotifier))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQSocketNotifier(unsafe.Pointer(notifier), nil)
+
+	gofunc(slotval1)
+
+}
+func (this *QAbstractEventDispatcher) OnRegisterTimer2(slot func(timerId int, interval int, timerType TimerType, object *QObject)) {
+	C.QAbstractEventDispatcher_override_virtual_RegisterTimer2(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2
+func miqt_exec_callback_QAbstractEventDispatcher_RegisterTimer2(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int, interval C.int, timerType C.int, object *C.QObject) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(timerId int, interval int, timerType TimerType, object *QObject))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(timerId)
+
+	slotval2 := (int)(interval)
+
+	slotval3 := (TimerType)(timerType)
+
+	slotval4 := UnsafeNewQObject(unsafe.Pointer(object))
+
+	gofunc(slotval1, slotval2, slotval3, slotval4)
+
+}
+func (this *QAbstractEventDispatcher) OnUnregisterTimer(slot func(timerId int) bool) {
+	C.QAbstractEventDispatcher_override_virtual_UnregisterTimer(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer
+func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimer(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(timerId)
+
+	virtualReturn := gofunc(slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAbstractEventDispatcher) OnUnregisterTimers(slot func(object *QObject) bool) {
+	C.QAbstractEventDispatcher_override_virtual_UnregisterTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers
+func miqt_exec_callback_QAbstractEventDispatcher_UnregisterTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
+
+	virtualReturn := gofunc(slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAbstractEventDispatcher) OnRegisteredTimers(slot func(object *QObject) []QAbstractEventDispatcher__TimerInfo) {
+	C.QAbstractEventDispatcher_override_virtual_RegisteredTimers(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers
+func miqt_exec_callback_QAbstractEventDispatcher_RegisteredTimers(self *C.QAbstractEventDispatcher, cb C.intptr_t, object *C.QObject) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(object *QObject) []QAbstractEventDispatcher__TimerInfo)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQObject(unsafe.Pointer(object))
+
+	virtualReturn := gofunc(slotval1)
+	virtualReturn_CArray := (*[0xffff]*C.QAbstractEventDispatcher__TimerInfo)(C.malloc(C.size_t(8 * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_CArray[i] = virtualReturn[i].cPointer()
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+func (this *QAbstractEventDispatcher) OnRemainingTime(slot func(timerId int) int) {
+	C.QAbstractEventDispatcher_override_virtual_RemainingTime(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_RemainingTime
+func miqt_exec_callback_QAbstractEventDispatcher_RemainingTime(self *C.QAbstractEventDispatcher, cb C.intptr_t, timerId C.int) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(timerId int) int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (int)(timerId)
+
+	virtualReturn := gofunc(slotval1)
+
+	return (C.int)(virtualReturn)
+
+}
+func (this *QAbstractEventDispatcher) OnWakeUp(slot func()) {
+	C.QAbstractEventDispatcher_override_virtual_WakeUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_WakeUp
+func miqt_exec_callback_QAbstractEventDispatcher_WakeUp(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+
+}
+func (this *QAbstractEventDispatcher) OnInterrupt(slot func()) {
+	C.QAbstractEventDispatcher_override_virtual_Interrupt(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_Interrupt
+func miqt_exec_callback_QAbstractEventDispatcher_Interrupt(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+
+}
+func (this *QAbstractEventDispatcher) OnFlush(slot func()) {
+	C.QAbstractEventDispatcher_override_virtual_Flush(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_Flush
+func miqt_exec_callback_QAbstractEventDispatcher_Flush(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_StartingUp() {
+
+	C.QAbstractEventDispatcher_virtualbase_StartingUp(unsafe.Pointer(this.h))
+
+}
+func (this *QAbstractEventDispatcher) OnStartingUp(slot func(super func())) {
+	C.QAbstractEventDispatcher_override_virtual_StartingUp(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_StartingUp
+func miqt_exec_callback_QAbstractEventDispatcher_StartingUp(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_StartingUp)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_ClosingDown() {
+
+	C.QAbstractEventDispatcher_virtualbase_ClosingDown(unsafe.Pointer(this.h))
+
+}
+func (this *QAbstractEventDispatcher) OnClosingDown(slot func(super func())) {
+	C.QAbstractEventDispatcher_override_virtual_ClosingDown(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_ClosingDown
+func miqt_exec_callback_QAbstractEventDispatcher_ClosingDown(self *C.QAbstractEventDispatcher, cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func()))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ClosingDown)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAbstractEventDispatcher_virtualbase_Event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAbstractEventDispatcher) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	C.QAbstractEventDispatcher_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_Event
+func miqt_exec_callback_QAbstractEventDispatcher_Event(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAbstractEventDispatcher_virtualbase_EventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAbstractEventDispatcher) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	C.QAbstractEventDispatcher_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_EventFilter
+func miqt_exec_callback_QAbstractEventDispatcher_EventFilter(self *C.QAbstractEventDispatcher, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQObject(unsafe.Pointer(watched))
+	slotval2 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAbstractEventDispatcher_virtualbase_TimerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractEventDispatcher) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	C.QAbstractEventDispatcher_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_TimerEvent
+func miqt_exec_callback_QAbstractEventDispatcher_TimerEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAbstractEventDispatcher_virtualbase_ChildEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractEventDispatcher) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	C.QAbstractEventDispatcher_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_ChildEvent
+func miqt_exec_callback_QAbstractEventDispatcher_ChildEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAbstractEventDispatcher_virtualbase_CustomEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractEventDispatcher) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	C.QAbstractEventDispatcher_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_CustomEvent
+func miqt_exec_callback_QAbstractEventDispatcher_CustomEvent(self *C.QAbstractEventDispatcher, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractEventDispatcher_virtualbase_ConnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractEventDispatcher) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractEventDispatcher_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify
+func miqt_exec_callback_QAbstractEventDispatcher_ConnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAbstractEventDispatcher) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractEventDispatcher_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractEventDispatcher) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractEventDispatcher_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify
+func miqt_exec_callback_QAbstractEventDispatcher_DisconnectNotify(self *C.QAbstractEventDispatcher, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractEventDispatcher{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
 
 // Delete this object from C++ memory.
 func (this *QAbstractEventDispatcher) Delete() {

qt/gen_qabstracteventdispatcher.h

@@ -23,21 +23,31 @@ class QAbstractEventDispatcher__TimerInfo;
 #endif
 class QAbstractNativeEventFilter;
 class QByteArray;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
 class QMetaObject;
 class QObject;
 class QSocketNotifier;
 class QThread;
+class QTimerEvent;
 #else
 typedef struct QAbstractEventDispatcher QAbstractEventDispatcher;
 typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo;
 typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter;
 typedef struct QByteArray QByteArray;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QObject QObject;
 typedef struct QSocketNotifier QSocketNotifier;
 typedef struct QThread QThread;
+typedef struct QTimerEvent QTimerEvent;
 #endif
 
+void QAbstractEventDispatcher_new(QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
+void QAbstractEventDispatcher_new2(QObject* parent, QAbstractEventDispatcher** outptr_QAbstractEventDispatcher, QObject** outptr_QObject);
 QMetaObject* QAbstractEventDispatcher_MetaObject(const QAbstractEventDispatcher* self);
 void* QAbstractEventDispatcher_Metacast(QAbstractEventDispatcher* self, const char* param1);
 struct miqt_string QAbstractEventDispatcher_Tr(const char* s);
@@ -70,6 +80,48 @@ struct miqt_string QAbstractEventDispatcher_Tr3(const char* s, const char* c, in
 struct miqt_string QAbstractEventDispatcher_TrUtf82(const char* s, const char* c);
 struct miqt_string QAbstractEventDispatcher_TrUtf83(const char* s, const char* c, int n);
 QAbstractEventDispatcher* QAbstractEventDispatcher_Instance1(QThread* thread);
+void QAbstractEventDispatcher_override_virtual_ProcessEvents(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_ProcessEvents(void* self, int flags);
+void QAbstractEventDispatcher_override_virtual_HasPendingEvents(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_HasPendingEvents(void* self);
+void QAbstractEventDispatcher_override_virtual_RegisterSocketNotifier(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_RegisterSocketNotifier(void* self, QSocketNotifier* notifier);
+void QAbstractEventDispatcher_override_virtual_UnregisterSocketNotifier(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_UnregisterSocketNotifier(void* self, QSocketNotifier* notifier);
+void QAbstractEventDispatcher_override_virtual_RegisterTimer2(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_RegisterTimer2(void* self, int timerId, int interval, int timerType, QObject* object);
+void QAbstractEventDispatcher_override_virtual_UnregisterTimer(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_UnregisterTimer(void* self, int timerId);
+void QAbstractEventDispatcher_override_virtual_UnregisterTimers(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_UnregisterTimers(void* self, QObject* object);
+void QAbstractEventDispatcher_override_virtual_RegisteredTimers(void* self, intptr_t slot);
+struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */  QAbstractEventDispatcher_virtualbase_RegisteredTimers(const void* self, QObject* object);
+void QAbstractEventDispatcher_override_virtual_RemainingTime(void* self, intptr_t slot);
+int QAbstractEventDispatcher_virtualbase_RemainingTime(void* self, int timerId);
+void QAbstractEventDispatcher_override_virtual_WakeUp(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_WakeUp(void* self);
+void QAbstractEventDispatcher_override_virtual_Interrupt(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_Interrupt(void* self);
+void QAbstractEventDispatcher_override_virtual_Flush(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_Flush(void* self);
+void QAbstractEventDispatcher_override_virtual_StartingUp(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_StartingUp(void* self);
+void QAbstractEventDispatcher_override_virtual_ClosingDown(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_ClosingDown(void* self);
+void QAbstractEventDispatcher_override_virtual_Event(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_Event(void* self, QEvent* event);
+void QAbstractEventDispatcher_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QAbstractEventDispatcher_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QAbstractEventDispatcher_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QAbstractEventDispatcher_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QAbstractEventDispatcher_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_CustomEvent(void* self, QEvent* event);
+void QAbstractEventDispatcher_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QAbstractEventDispatcher_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QAbstractEventDispatcher_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QAbstractEventDispatcher_Delete(QAbstractEventDispatcher* self, bool isSubclass);
 
 void QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t, QAbstractEventDispatcher__TimerInfo** outptr_QAbstractEventDispatcher__TimerInfo);

qt/gen_qabstractitemdelegate.cpp

@@ -1,10 +1,12 @@
 #include <QAbstractItemDelegate>
 #include <QAbstractItemModel>
 #include <QAbstractItemView>
+#include <QChildEvent>
 #include <QEvent>
 #include <QFontMetrics>
 #include <QHelpEvent>
 #include <QList>
+#include <QMetaMethod>
 #include <QMetaObject>
 #include <QModelIndex>
 #include <QObject>
@@ -14,11 +16,486 @@
 #include <QByteArray>
 #include <cstring>
 #include <QStyleOptionViewItem>
+#include <QTimerEvent>
 #include <QWidget>
 #include <qabstractitemdelegate.h>
 #include "gen_qabstractitemdelegate.h"
 #include "_cgo_export.h"
 
+class MiqtVirtualQAbstractItemDelegate : public virtual QAbstractItemDelegate {
+public:
+
+	MiqtVirtualQAbstractItemDelegate(): QAbstractItemDelegate() {};
+	MiqtVirtualQAbstractItemDelegate(QObject* parent): QAbstractItemDelegate(parent) {};
+
+	virtual ~MiqtVirtualQAbstractItemDelegate() = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Paint = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__Paint == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+		
+		QPainter* sigval1 = painter;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_Paint(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__Paint, sigval1, sigval2, sigval3);
+
+		
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__SizeHint = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__SizeHint == 0) {
+			return QSize(); // Pure virtual, there is no base we can call
+		}
+		
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval1 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+
+		QSize* callback_return_value = miqt_exec_callback_QAbstractItemDelegate_SizeHint(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__SizeHint, sigval1, sigval2);
+
+		return *callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CreateEditor = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__CreateEditor == 0) {
+			return QAbstractItemDelegate::createEditor(parent, option, index);
+		}
+		
+		QWidget* sigval1 = parent;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+
+		QWidget* callback_return_value = miqt_exec_callback_QAbstractItemDelegate_CreateEditor(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__CreateEditor, sigval1, sigval2, sigval3);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	QWidget* virtualbase_CreateEditor(QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index) const {
+
+		return QAbstractItemDelegate::createEditor(parent, *option, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DestroyEditor = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void destroyEditor(QWidget* editor, const QModelIndex& index) const override {
+		if (handle__DestroyEditor == 0) {
+			QAbstractItemDelegate::destroyEditor(editor, index);
+			return;
+		}
+		
+		QWidget* sigval1 = editor;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_DestroyEditor(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__DestroyEditor, sigval1, sigval2);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DestroyEditor(QWidget* editor, QModelIndex* index) const {
+
+		QAbstractItemDelegate::destroyEditor(editor, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__SetEditorData = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void setEditorData(QWidget* editor, const QModelIndex& index) const override {
+		if (handle__SetEditorData == 0) {
+			QAbstractItemDelegate::setEditorData(editor, index);
+			return;
+		}
+		
+		QWidget* sigval1 = editor;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_SetEditorData(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__SetEditorData, sigval1, sigval2);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_SetEditorData(QWidget* editor, QModelIndex* index) const {
+
+		QAbstractItemDelegate::setEditorData(editor, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__SetModelData = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override {
+		if (handle__SetModelData == 0) {
+			QAbstractItemDelegate::setModelData(editor, model, index);
+			return;
+		}
+		
+		QWidget* sigval1 = editor;
+		QAbstractItemModel* sigval2 = model;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_SetModelData(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__SetModelData, sigval1, sigval2, sigval3);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_SetModelData(QWidget* editor, QAbstractItemModel* model, QModelIndex* index) const {
+
+		QAbstractItemDelegate::setModelData(editor, model, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__UpdateEditorGeometry = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__UpdateEditorGeometry == 0) {
+			QAbstractItemDelegate::updateEditorGeometry(editor, option, index);
+			return;
+		}
+		
+		QWidget* sigval1 = editor;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_UpdateEditorGeometry(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__UpdateEditorGeometry, sigval1, sigval2, sigval3);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_UpdateEditorGeometry(QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index) const {
+
+		QAbstractItemDelegate::updateEditorGeometry(editor, *option, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EditorEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) override {
+		if (handle__EditorEvent == 0) {
+			return QAbstractItemDelegate::editorEvent(event, model, option, index);
+		}
+		
+		QEvent* sigval1 = event;
+		QAbstractItemModel* sigval2 = model;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval3 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval4 = const_cast<QModelIndex*>(&index_ret);
+
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_EditorEvent(this, handle__EditorEvent, sigval1, sigval2, sigval3, sigval4);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EditorEvent(QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index) {
+
+		return QAbstractItemDelegate::editorEvent(event, model, *option, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__HelpEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool helpEvent(QHelpEvent* event, QAbstractItemView* view, const QStyleOptionViewItem& option, const QModelIndex& index) override {
+		if (handle__HelpEvent == 0) {
+			return QAbstractItemDelegate::helpEvent(event, view, option, index);
+		}
+		
+		QHelpEvent* sigval1 = event;
+		QAbstractItemView* sigval2 = view;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval3 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval4 = const_cast<QModelIndex*>(&index_ret);
+
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_HelpEvent(this, handle__HelpEvent, sigval1, sigval2, sigval3, sigval4);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_HelpEvent(QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index) {
+
+		return QAbstractItemDelegate::helpEvent(event, view, *option, *index);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__PaintingRoles = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QVector<int> paintingRoles() const override {
+		if (handle__PaintingRoles == 0) {
+			return QAbstractItemDelegate::paintingRoles();
+		}
+		
+
+		struct miqt_array /* of int */  callback_return_value = miqt_exec_callback_QAbstractItemDelegate_PaintingRoles(const_cast<MiqtVirtualQAbstractItemDelegate*>(this), handle__PaintingRoles);
+		QVector<int> callback_return_value_QList;
+		callback_return_value_QList.reserve(callback_return_value.len);
+		int* callback_return_value_arr = static_cast<int*>(callback_return_value.data);
+		for(size_t i = 0; i < callback_return_value.len; ++i) {
+			callback_return_value_QList.push_back(static_cast<int>(callback_return_value_arr[i]));
+		}
+
+		return callback_return_value_QList;
+	}
+
+	// Wrapper to allow calling protected method
+	struct miqt_array /* of int */  virtualbase_PaintingRoles() const {
+
+		QVector<int> _ret = QAbstractItemDelegate::paintingRoles();
+		// Convert QList<> from C++ memory to manually-managed C memory
+		int* _arr = static_cast<int*>(malloc(sizeof(int) * _ret.length()));
+		for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+			_arr[i] = _ret[i];
+		}
+		struct miqt_array _out;
+		_out.len = _ret.length();
+		_out.data = static_cast<void*>(_arr);
+		return _out;
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__Event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__Event == 0) {
+			return QAbstractItemDelegate::event(event);
+		}
+		
+		QEvent* sigval1 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_Event(this, handle__Event, sigval1);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_Event(QEvent* event) {
+
+		return QAbstractItemDelegate::event(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__EventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__EventFilter == 0) {
+			return QAbstractItemDelegate::eventFilter(watched, event);
+		}
+		
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_EventFilter(this, handle__EventFilter, sigval1, sigval2);
+
+		return callback_return_value;
+	}
+
+	// Wrapper to allow calling protected method
+	bool virtualbase_EventFilter(QObject* watched, QEvent* event) {
+
+		return QAbstractItemDelegate::eventFilter(watched, event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__TimerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__TimerEvent == 0) {
+			QAbstractItemDelegate::timerEvent(event);
+			return;
+		}
+		
+		QTimerEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractItemDelegate_TimerEvent(this, handle__TimerEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_TimerEvent(QTimerEvent* event) {
+
+		QAbstractItemDelegate::timerEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ChildEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__ChildEvent == 0) {
+			QAbstractItemDelegate::childEvent(event);
+			return;
+		}
+		
+		QChildEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractItemDelegate_ChildEvent(this, handle__ChildEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ChildEvent(QChildEvent* event) {
+
+		QAbstractItemDelegate::childEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__CustomEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__CustomEvent == 0) {
+			QAbstractItemDelegate::customEvent(event);
+			return;
+		}
+		
+		QEvent* sigval1 = event;
+
+		miqt_exec_callback_QAbstractItemDelegate_CustomEvent(this, handle__CustomEvent, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_CustomEvent(QEvent* event) {
+
+		QAbstractItemDelegate::customEvent(event);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__ConnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__ConnectNotify == 0) {
+			QAbstractItemDelegate::connectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_ConnectNotify(this, handle__ConnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_ConnectNotify(QMetaMethod* signal) {
+
+		QAbstractItemDelegate::connectNotify(*signal);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__DisconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__DisconnectNotify == 0) {
+			QAbstractItemDelegate::disconnectNotify(signal);
+			return;
+		}
+		
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+
+		miqt_exec_callback_QAbstractItemDelegate_DisconnectNotify(this, handle__DisconnectNotify, sigval1);
+
+		
+	}
+
+	// Wrapper to allow calling protected method
+	void virtualbase_DisconnectNotify(QMetaMethod* signal) {
+
+		QAbstractItemDelegate::disconnectNotify(*signal);
+
+	}
+
+};
+
+void QAbstractItemDelegate_new(QAbstractItemDelegate** outptr_QAbstractItemDelegate, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractItemDelegate* ret = new MiqtVirtualQAbstractItemDelegate();
+	*outptr_QAbstractItemDelegate = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
+void QAbstractItemDelegate_new2(QObject* parent, QAbstractItemDelegate** outptr_QAbstractItemDelegate, QObject** outptr_QObject) {
+	MiqtVirtualQAbstractItemDelegate* ret = new MiqtVirtualQAbstractItemDelegate(parent);
+	*outptr_QAbstractItemDelegate = ret;
+	*outptr_QObject = static_cast<QObject*>(ret);
+}
+
 QMetaObject* QAbstractItemDelegate_MetaObject(const QAbstractItemDelegate* self) {
 	return (QMetaObject*) self->metaObject();
 }
@@ -115,7 +592,7 @@ void QAbstractItemDelegate_CommitData(QAbstractItemDelegate* self, QWidget* edit
 }
 
 void QAbstractItemDelegate_connect_CommitData(QAbstractItemDelegate* self, intptr_t slot) {
-	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*)>(&QAbstractItemDelegate::commitData), self, [=](QWidget* editor) {
+	MiqtVirtualQAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*)>(&QAbstractItemDelegate::commitData), self, [=](QWidget* editor) {
 		QWidget* sigval1 = editor;
 		miqt_exec_callback_QAbstractItemDelegate_CommitData(slot, sigval1);
 	});
@@ -126,7 +603,7 @@ void QAbstractItemDelegate_CloseEditor(QAbstractItemDelegate* self, QWidget* edi
 }
 
 void QAbstractItemDelegate_connect_CloseEditor(QAbstractItemDelegate* self, intptr_t slot) {
-	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor) {
+	MiqtVirtualQAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor) {
 		QWidget* sigval1 = editor;
 		miqt_exec_callback_QAbstractItemDelegate_CloseEditor(slot, sigval1);
 	});
@@ -137,7 +614,7 @@ void QAbstractItemDelegate_SizeHintChanged(QAbstractItemDelegate* self, QModelIn
 }
 
 void QAbstractItemDelegate_connect_SizeHintChanged(QAbstractItemDelegate* self, intptr_t slot) {
-	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(const QModelIndex&)>(&QAbstractItemDelegate::sizeHintChanged), self, [=](const QModelIndex& param1) {
+	MiqtVirtualQAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(const QModelIndex&)>(&QAbstractItemDelegate::sizeHintChanged), self, [=](const QModelIndex& param1) {
 		const QModelIndex& param1_ret = param1;
 		// Cast returned reference into pointer
 		QModelIndex* sigval1 = const_cast<QModelIndex*>(&param1_ret);
@@ -194,7 +671,7 @@ void QAbstractItemDelegate_CloseEditor2(QAbstractItemDelegate* self, QWidget* ed
 }
 
 void QAbstractItemDelegate_connect_CloseEditor2(QAbstractItemDelegate* self, intptr_t slot) {
-	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor, QAbstractItemDelegate::EndEditHint hint) {
+	MiqtVirtualQAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor, QAbstractItemDelegate::EndEditHint hint) {
 		QWidget* sigval1 = editor;
 		QAbstractItemDelegate::EndEditHint hint_ret = hint;
 		int sigval2 = static_cast<int>(hint_ret);
@@ -202,9 +679,137 @@ void QAbstractItemDelegate_connect_CloseEditor2(QAbstractItemDelegate* self, int
 	});
 }
 
+void QAbstractItemDelegate_override_virtual_Paint(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__Paint = slot;
+}
+
+void QAbstractItemDelegate_override_virtual_SizeHint(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__SizeHint = slot;
+}
+
+void QAbstractItemDelegate_override_virtual_CreateEditor(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__CreateEditor = slot;
+}
+
+QWidget* QAbstractItemDelegate_virtualbase_CreateEditor(const void* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index) {
+	return ( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_CreateEditor(parent, option, index);
+}
+
+void QAbstractItemDelegate_override_virtual_DestroyEditor(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__DestroyEditor = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_DestroyEditor(const void* self, QWidget* editor, QModelIndex* index) {
+	( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_DestroyEditor(editor, index);
+}
+
+void QAbstractItemDelegate_override_virtual_SetEditorData(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__SetEditorData = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_SetEditorData(const void* self, QWidget* editor, QModelIndex* index) {
+	( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_SetEditorData(editor, index);
+}
+
+void QAbstractItemDelegate_override_virtual_SetModelData(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__SetModelData = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_SetModelData(const void* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index) {
+	( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_SetModelData(editor, model, index);
+}
+
+void QAbstractItemDelegate_override_virtual_UpdateEditorGeometry(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__UpdateEditorGeometry = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_UpdateEditorGeometry(const void* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index) {
+	( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_UpdateEditorGeometry(editor, option, index);
+}
+
+void QAbstractItemDelegate_override_virtual_EditorEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__EditorEvent = slot;
+}
+
+bool QAbstractItemDelegate_virtualbase_EditorEvent(void* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index) {
+	return ( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_EditorEvent(event, model, option, index);
+}
+
+void QAbstractItemDelegate_override_virtual_HelpEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__HelpEvent = slot;
+}
+
+bool QAbstractItemDelegate_virtualbase_HelpEvent(void* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index) {
+	return ( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_HelpEvent(event, view, option, index);
+}
+
+void QAbstractItemDelegate_override_virtual_PaintingRoles(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__PaintingRoles = slot;
+}
+
+struct miqt_array /* of int */  QAbstractItemDelegate_virtualbase_PaintingRoles(const void* self) {
+	return ( (const MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_PaintingRoles();
+}
+
+void QAbstractItemDelegate_override_virtual_Event(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__Event = slot;
+}
+
+bool QAbstractItemDelegate_virtualbase_Event(void* self, QEvent* event) {
+	return ( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_Event(event);
+}
+
+void QAbstractItemDelegate_override_virtual_EventFilter(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__EventFilter = slot;
+}
+
+bool QAbstractItemDelegate_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event) {
+	return ( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_EventFilter(watched, event);
+}
+
+void QAbstractItemDelegate_override_virtual_TimerEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__TimerEvent = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_TimerEvent(void* self, QTimerEvent* event) {
+	( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_TimerEvent(event);
+}
+
+void QAbstractItemDelegate_override_virtual_ChildEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__ChildEvent = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_ChildEvent(void* self, QChildEvent* event) {
+	( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_ChildEvent(event);
+}
+
+void QAbstractItemDelegate_override_virtual_CustomEvent(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__CustomEvent = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_CustomEvent(void* self, QEvent* event) {
+	( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_CustomEvent(event);
+}
+
+void QAbstractItemDelegate_override_virtual_ConnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__ConnectNotify = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_ConnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_ConnectNotify(signal);
+}
+
+void QAbstractItemDelegate_override_virtual_DisconnectNotify(void* self, intptr_t slot) {
+	dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) )->handle__DisconnectNotify = slot;
+}
+
+void QAbstractItemDelegate_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal) {
+	( (MiqtVirtualQAbstractItemDelegate*)(self) )->virtualbase_DisconnectNotify(signal);
+}
+
 void QAbstractItemDelegate_Delete(QAbstractItemDelegate* self, bool isSubclass) {
 	if (isSubclass) {
-		delete dynamic_cast<QAbstractItemDelegate*>( self );
+		delete dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( self );
 	} else {
 		delete self;
 	}

qt/gen_qabstractitemdelegate.go

@@ -63,6 +63,28 @@ func UnsafeNewQAbstractItemDelegate(h unsafe.Pointer, h_QObject unsafe.Pointer)
 		QObject: UnsafeNewQObject(h_QObject)}
 }
 
+// NewQAbstractItemDelegate constructs a new QAbstractItemDelegate object.
+func NewQAbstractItemDelegate() *QAbstractItemDelegate {
+	var outptr_QAbstractItemDelegate *C.QAbstractItemDelegate = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractItemDelegate_new(&outptr_QAbstractItemDelegate, &outptr_QObject)
+	ret := newQAbstractItemDelegate(outptr_QAbstractItemDelegate, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
+// NewQAbstractItemDelegate2 constructs a new QAbstractItemDelegate object.
+func NewQAbstractItemDelegate2(parent *QObject) *QAbstractItemDelegate {
+	var outptr_QAbstractItemDelegate *C.QAbstractItemDelegate = nil
+	var outptr_QObject *C.QObject = nil
+
+	C.QAbstractItemDelegate_new2(parent.cPointer(), &outptr_QAbstractItemDelegate, &outptr_QObject)
+	ret := newQAbstractItemDelegate(outptr_QAbstractItemDelegate, outptr_QObject)
+	ret.isSubclass = true
+	return ret
+}
+
 func (this *QAbstractItemDelegate) MetaObject() *QMetaObject {
 	return UnsafeNewQMetaObject(unsafe.Pointer(C.QAbstractItemDelegate_MetaObject(this.h)))
 }
@@ -276,6 +298,426 @@ func miqt_exec_callback_QAbstractItemDelegate_CloseEditor2(cb C.intptr_t, editor
 	gofunc(slotval1, slotval2)
 }
 
+func (this *QAbstractItemDelegate) OnPaint(slot func(painter *QPainter, option *QStyleOptionViewItem, index *QModelIndex)) {
+	C.QAbstractItemDelegate_override_virtual_Paint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_Paint
+func miqt_exec_callback_QAbstractItemDelegate_Paint(self *C.QAbstractItemDelegate, cb C.intptr_t, painter *C.QPainter, option *C.QStyleOptionViewItem, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(painter *QPainter, option *QStyleOptionViewItem, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQPainter(unsafe.Pointer(painter))
+	slotval2 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval3 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	gofunc(slotval1, slotval2, slotval3)
+
+}
+func (this *QAbstractItemDelegate) OnSizeHint(slot func(option *QStyleOptionViewItem, index *QModelIndex) *QSize) {
+	C.QAbstractItemDelegate_override_virtual_SizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_SizeHint
+func miqt_exec_callback_QAbstractItemDelegate_SizeHint(self *C.QAbstractItemDelegate, cb C.intptr_t, option *C.QStyleOptionViewItem, index *C.QModelIndex) *C.QSize {
+	gofunc, ok := cgo.Handle(cb).Value().(func(option *QStyleOptionViewItem, index *QModelIndex) *QSize)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval2 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	virtualReturn := gofunc(slotval1, slotval2)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_CreateEditor(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget {
+
+	return UnsafeNewQWidget(unsafe.Pointer(C.QAbstractItemDelegate_virtualbase_CreateEditor(unsafe.Pointer(this.h), parent.cPointer(), option.cPointer(), index.cPointer())), nil, nil)
+}
+func (this *QAbstractItemDelegate) OnCreateEditor(slot func(super func(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget, parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget) {
+	C.QAbstractItemDelegate_override_virtual_CreateEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_CreateEditor
+func miqt_exec_callback_QAbstractItemDelegate_CreateEditor(self *C.QAbstractItemDelegate, cb C.intptr_t, parent *C.QWidget, option *C.QStyleOptionViewItem, index *C.QModelIndex) *C.QWidget {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget, parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQWidget(unsafe.Pointer(parent), nil, nil)
+	slotval2 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval3 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_CreateEditor, slotval1, slotval2, slotval3)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_DestroyEditor(editor *QWidget, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_DestroyEditor(unsafe.Pointer(this.h), editor.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnDestroyEditor(slot func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex)) {
+	C.QAbstractItemDelegate_override_virtual_DestroyEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_DestroyEditor
+func miqt_exec_callback_QAbstractItemDelegate_DestroyEditor(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQWidget(unsafe.Pointer(editor), nil, nil)
+	slotval2 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_DestroyEditor, slotval1, slotval2)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_SetEditorData(editor *QWidget, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_SetEditorData(unsafe.Pointer(this.h), editor.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnSetEditorData(slot func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex)) {
+	C.QAbstractItemDelegate_override_virtual_SetEditorData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_SetEditorData
+func miqt_exec_callback_QAbstractItemDelegate_SetEditorData(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQWidget(unsafe.Pointer(editor), nil, nil)
+	slotval2 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_SetEditorData, slotval1, slotval2)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_SetModelData(editor *QWidget, model *QAbstractItemModel, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_SetModelData(unsafe.Pointer(this.h), editor.cPointer(), model.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnSetModelData(slot func(super func(editor *QWidget, model *QAbstractItemModel, index *QModelIndex), editor *QWidget, model *QAbstractItemModel, index *QModelIndex)) {
+	C.QAbstractItemDelegate_override_virtual_SetModelData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_SetModelData
+func miqt_exec_callback_QAbstractItemDelegate_SetModelData(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, model *C.QAbstractItemModel, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, model *QAbstractItemModel, index *QModelIndex), editor *QWidget, model *QAbstractItemModel, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQWidget(unsafe.Pointer(editor), nil, nil)
+	slotval2 := UnsafeNewQAbstractItemModel(unsafe.Pointer(model), nil)
+	slotval3 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_SetModelData, slotval1, slotval2, slotval3)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_UpdateEditorGeometry(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_UpdateEditorGeometry(unsafe.Pointer(this.h), editor.cPointer(), option.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnUpdateEditorGeometry(slot func(super func(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex), editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex)) {
+	C.QAbstractItemDelegate_override_virtual_UpdateEditorGeometry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_UpdateEditorGeometry
+func miqt_exec_callback_QAbstractItemDelegate_UpdateEditorGeometry(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, option *C.QStyleOptionViewItem, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex), editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQWidget(unsafe.Pointer(editor), nil, nil)
+	slotval2 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval3 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_UpdateEditorGeometry, slotval1, slotval2, slotval3)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_EditorEvent(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_EditorEvent(unsafe.Pointer(this.h), event.cPointer(), model.cPointer(), option.cPointer(), index.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEditorEvent(slot func(super func(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool) {
+	C.QAbstractItemDelegate_override_virtual_EditorEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_EditorEvent
+func miqt_exec_callback_QAbstractItemDelegate_EditorEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent, model *C.QAbstractItemModel, option *C.QStyleOptionViewItem, index *C.QModelIndex) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+	slotval2 := UnsafeNewQAbstractItemModel(unsafe.Pointer(model), nil)
+	slotval3 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval4 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_EditorEvent, slotval1, slotval2, slotval3, slotval4)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_HelpEvent(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_HelpEvent(unsafe.Pointer(this.h), event.cPointer(), view.cPointer(), option.cPointer(), index.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnHelpEvent(slot func(super func(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool) {
+	C.QAbstractItemDelegate_override_virtual_HelpEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_HelpEvent
+func miqt_exec_callback_QAbstractItemDelegate_HelpEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QHelpEvent, view *C.QAbstractItemView, option *C.QStyleOptionViewItem, index *C.QModelIndex) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQHelpEvent(unsafe.Pointer(event), nil)
+	slotval2 := UnsafeNewQAbstractItemView(unsafe.Pointer(view), nil, nil, nil, nil, nil)
+	slotval3 := UnsafeNewQStyleOptionViewItem(unsafe.Pointer(option), nil)
+	slotval4 := UnsafeNewQModelIndex(unsafe.Pointer(index))
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_HelpEvent, slotval1, slotval2, slotval3, slotval4)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_PaintingRoles() []int {
+
+	var _ma C.struct_miqt_array = C.QAbstractItemDelegate_virtualbase_PaintingRoles(unsafe.Pointer(this.h))
+	_ret := make([]int, int(_ma.len))
+	_outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = (int)(_outCast[i])
+	}
+	return _ret
+
+}
+func (this *QAbstractItemDelegate) OnPaintingRoles(slot func(super func() []int) []int) {
+	C.QAbstractItemDelegate_override_virtual_PaintingRoles(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_PaintingRoles
+func miqt_exec_callback_QAbstractItemDelegate_PaintingRoles(self *C.QAbstractItemDelegate, cb C.intptr_t) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() []int) []int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_PaintingRoles)
+	virtualReturn_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_CArray[i] = (C.int)(virtualReturn[i])
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_Event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	C.QAbstractItemDelegate_override_virtual_Event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_Event
+func miqt_exec_callback_QAbstractItemDelegate_Event(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_EventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	C.QAbstractItemDelegate_override_virtual_EventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_EventFilter
+func miqt_exec_callback_QAbstractItemDelegate_EventFilter(self *C.QAbstractItemDelegate, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQObject(unsafe.Pointer(watched))
+	slotval2 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_TimerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	C.QAbstractItemDelegate_override_virtual_TimerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_TimerEvent
+func miqt_exec_callback_QAbstractItemDelegate_TimerEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQTimerEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_ChildEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	C.QAbstractItemDelegate_override_virtual_ChildEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_ChildEvent
+func miqt_exec_callback_QAbstractItemDelegate_ChildEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQChildEvent(unsafe.Pointer(event), nil)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_CustomEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	C.QAbstractItemDelegate_override_virtual_CustomEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_CustomEvent
+func miqt_exec_callback_QAbstractItemDelegate_CustomEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractItemDelegate_virtualbase_ConnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractItemDelegate_override_virtual_ConnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_ConnectNotify
+func miqt_exec_callback_QAbstractItemDelegate_ConnectNotify(self *C.QAbstractItemDelegate, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractItemDelegate_virtualbase_DisconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	C.QAbstractItemDelegate_override_virtual_DisconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_DisconnectNotify
+func miqt_exec_callback_QAbstractItemDelegate_DisconnectNotify(self *C.QAbstractItemDelegate, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
 // Delete this object from C++ memory.
 func (this *QAbstractItemDelegate) Delete() {
 	C.QAbstractItemDelegate_Delete(this.h, C.bool(this.isSubclass))

qt/gen_qabstractitemdelegate.h

@@ -18,32 +18,40 @@ extern "C" {
 class QAbstractItemDelegate;
 class QAbstractItemModel;
 class QAbstractItemView;
+class QChildEvent;
 class QEvent;
 class QFontMetrics;
 class QHelpEvent;
+class QMetaMethod;
 class QMetaObject;
 class QModelIndex;
 class QObject;
 class QPainter;
 class QSize;
 class QStyleOptionViewItem;
+class QTimerEvent;
 class QWidget;
 #else
 typedef struct QAbstractItemDelegate QAbstractItemDelegate;
 typedef struct QAbstractItemModel QAbstractItemModel;
 typedef struct QAbstractItemView QAbstractItemView;
+typedef struct QChildEvent QChildEvent;
 typedef struct QEvent QEvent;
 typedef struct QFontMetrics QFontMetrics;
 typedef struct QHelpEvent QHelpEvent;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QModelIndex QModelIndex;
 typedef struct QObject QObject;
 typedef struct QPainter QPainter;
 typedef struct QSize QSize;
 typedef struct QStyleOptionViewItem QStyleOptionViewItem;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QWidget QWidget;
 #endif
 
+void QAbstractItemDelegate_new(QAbstractItemDelegate** outptr_QAbstractItemDelegate, QObject** outptr_QObject);
+void QAbstractItemDelegate_new2(QObject* parent, QAbstractItemDelegate** outptr_QAbstractItemDelegate, QObject** outptr_QObject);
 QMetaObject* QAbstractItemDelegate_MetaObject(const QAbstractItemDelegate* self);
 void* QAbstractItemDelegate_Metacast(QAbstractItemDelegate* self, const char* param1);
 struct miqt_string QAbstractItemDelegate_Tr(const char* s);
@@ -71,6 +79,40 @@ struct miqt_string QAbstractItemDelegate_TrUtf82(const char* s, const char* c);
 struct miqt_string QAbstractItemDelegate_TrUtf83(const char* s, const char* c, int n);
 void QAbstractItemDelegate_CloseEditor2(QAbstractItemDelegate* self, QWidget* editor, int hint);
 void QAbstractItemDelegate_connect_CloseEditor2(QAbstractItemDelegate* self, intptr_t slot);
+void QAbstractItemDelegate_override_virtual_Paint(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_Paint(const void* self, QPainter* painter, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_SizeHint(void* self, intptr_t slot);
+QSize* QAbstractItemDelegate_virtualbase_SizeHint(const void* self, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_CreateEditor(void* self, intptr_t slot);
+QWidget* QAbstractItemDelegate_virtualbase_CreateEditor(const void* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_DestroyEditor(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_DestroyEditor(const void* self, QWidget* editor, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_SetEditorData(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_SetEditorData(const void* self, QWidget* editor, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_SetModelData(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_SetModelData(const void* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_UpdateEditorGeometry(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_UpdateEditorGeometry(const void* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_EditorEvent(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_EditorEvent(void* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_HelpEvent(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_HelpEvent(void* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_override_virtual_PaintingRoles(void* self, intptr_t slot);
+struct miqt_array /* of int */  QAbstractItemDelegate_virtualbase_PaintingRoles(const void* self);
+void QAbstractItemDelegate_override_virtual_Event(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_Event(void* self, QEvent* event);
+void QAbstractItemDelegate_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QAbstractItemDelegate_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QAbstractItemDelegate_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QAbstractItemDelegate_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_CustomEvent(void* self, QEvent* event);
+void QAbstractItemDelegate_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QAbstractItemDelegate_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QAbstractItemDelegate_Delete(QAbstractItemDelegate* self, bool isSubclass);
 
 #ifdef __cplusplus

qt/gen_qabstractitemmodel.h

@@ -19,24 +19,32 @@ class QAbstractItemModel;
 class QAbstractListModel;
 class QAbstractTableModel;
 class QByteArray;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
 class QMetaObject;
 class QMimeData;
 class QModelIndex;
 class QObject;
 class QPersistentModelIndex;
 class QSize;
+class QTimerEvent;
 class QVariant;
 #else
 typedef struct QAbstractItemModel QAbstractItemModel;
 typedef struct QAbstractListModel QAbstractListModel;
 typedef struct QAbstractTableModel QAbstractTableModel;
 typedef struct QByteArray QByteArray;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
 typedef struct QMetaObject QMetaObject;
 typedef struct QMimeData QMimeData;
 typedef struct QModelIndex QModelIndex;
 typedef struct QObject QObject;
 typedef struct QPersistentModelIndex QPersistentModelIndex;
 typedef struct QSize QSize;
+typedef struct QTimerEvent QTimerEvent;
 typedef struct QVariant QVariant;
 #endif
 
@@ -86,6 +94,8 @@ bool QPersistentModelIndex_IsValid(const QPersistentModelIndex* self);
 QVariant* QPersistentModelIndex_Data1(const QPersistentModelIndex* self, int role);
 void QPersistentModelIndex_Delete(QPersistentModelIndex* self, bool isSubclass);
 
+void QAbstractItemModel_new(QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
+void QAbstractItemModel_new2(QObject* parent, QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
 QMetaObject* QAbstractItemModel_MetaObject(const QAbstractItemModel* self);
 void* QAbstractItemModel_Metacast(QAbstractItemModel* self, const char* param1);
 struct miqt_string QAbstractItemModel_Tr(const char* s);
@@ -160,8 +170,92 @@ void QAbstractItemModel_LayoutAboutToBeChanged1(QAbstractItemModel* self, struct
 void QAbstractItemModel_connect_LayoutAboutToBeChanged1(QAbstractItemModel* self, intptr_t slot);
 void QAbstractItemModel_LayoutAboutToBeChanged2(QAbstractItemModel* self, struct miqt_array /* of QPersistentModelIndex* */  parents, int hint);
 void QAbstractItemModel_connect_LayoutAboutToBeChanged2(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_override_virtual_Index(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_Index(const void* self, int row, int column, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_Parent(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_Parent(const void* self, QModelIndex* child);
+void QAbstractItemModel_override_virtual_Sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_Sibling(const void* self, int row, int column, QModelIndex* idx);
+void QAbstractItemModel_override_virtual_RowCount(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_RowCount(const void* self, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_ColumnCount(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_ColumnCount(const void* self, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_HasChildren(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_HasChildren(const void* self, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_Data(void* self, intptr_t slot);
+QVariant* QAbstractItemModel_virtualbase_Data(const void* self, QModelIndex* index, int role);
+void QAbstractItemModel_override_virtual_SetData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_SetData(void* self, QModelIndex* index, QVariant* value, int role);
+void QAbstractItemModel_override_virtual_HeaderData(void* self, intptr_t slot);
+QVariant* QAbstractItemModel_virtualbase_HeaderData(const void* self, int section, int orientation, int role);
+void QAbstractItemModel_override_virtual_SetHeaderData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_SetHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+void QAbstractItemModel_override_virtual_ItemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractItemModel_virtualbase_ItemData(const void* self, QModelIndex* index);
+void QAbstractItemModel_override_virtual_SetItemData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_SetItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+void QAbstractItemModel_override_virtual_MimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractItemModel_virtualbase_MimeTypes(const void* self);
+void QAbstractItemModel_override_virtual_MimeData(void* self, intptr_t slot);
+QMimeData* QAbstractItemModel_virtualbase_MimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+void QAbstractItemModel_override_virtual_CanDropMimeData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_CanDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_DropMimeData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_DropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_SupportedDropActions(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_SupportedDropActions(const void* self);
+void QAbstractItemModel_override_virtual_SupportedDragActions(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_SupportedDragActions(const void* self);
+void QAbstractItemModel_override_virtual_InsertRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_InsertRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_InsertColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_InsertColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_RemoveRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_RemoveRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_RemoveColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_RemoveColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_MoveRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_MoveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractItemModel_override_virtual_MoveColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_MoveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractItemModel_override_virtual_FetchMore(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_FetchMore(void* self, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_CanFetchMore(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_CanFetchMore(const void* self, QModelIndex* parent);
+void QAbstractItemModel_override_virtual_Flags(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_Flags(const void* self, QModelIndex* index);
+void QAbstractItemModel_override_virtual_Sort(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_Sort(void* self, int column, int order);
+void QAbstractItemModel_override_virtual_Buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_Buddy(const void* self, QModelIndex* index);
+void QAbstractItemModel_override_virtual_Match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractItemModel_virtualbase_Match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+void QAbstractItemModel_override_virtual_Span(void* self, intptr_t slot);
+QSize* QAbstractItemModel_virtualbase_Span(const void* self, QModelIndex* index);
+void QAbstractItemModel_override_virtual_RoleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractItemModel_virtualbase_RoleNames(const void* self);
+void QAbstractItemModel_override_virtual_Submit(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_Submit(void* self);
+void QAbstractItemModel_override_virtual_Revert(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_Revert(void* self);
+void QAbstractItemModel_override_virtual_Event(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_Event(void* self, QEvent* event);
+void QAbstractItemModel_override_virtual_EventFilter(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_EventFilter(void* self, QObject* watched, QEvent* event);
+void QAbstractItemModel_override_virtual_TimerEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_TimerEvent(void* self, QTimerEvent* event);
+void QAbstractItemModel_override_virtual_ChildEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_ChildEvent(void* self, QChildEvent* event);
+void QAbstractItemModel_override_virtual_CustomEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_CustomEvent(void* self, QEvent* event);
+void QAbstractItemModel_override_virtual_ConnectNotify(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_ConnectNotify(void* self, QMetaMethod* signal);
+void QAbstractItemModel_override_virtual_DisconnectNotify(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_DisconnectNotify(void* self, QMetaMethod* signal);
 void QAbstractItemModel_Delete(QAbstractItemModel* self, bool isSubclass);
 
+void QAbstractTableModel_new(QAbstractTableModel** outptr_QAbstractTableModel, QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
+void QAbstractTableModel_new2(QObject* parent, QAbstractTableModel** outptr_QAbstractTableModel, QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
 QMetaObject* QAbstractTableModel_MetaObject(const QAbstractTableModel* self);
 void* QAbstractTableModel_Metacast(QAbstractTableModel* self, const char* param1);
 struct miqt_string QAbstractTableModel_Tr(const char* s);
@@ -174,8 +268,74 @@ struct miqt_string QAbstractTableModel_Tr2(const char* s, const char* c);
 struct miqt_string QAbstractTableModel_Tr3(const char* s, const char* c, int n);
 struct miqt_string QAbstractTableModel_TrUtf82(const char* s, const char* c);
 struct miqt_string QAbstractTableModel_TrUtf83(const char* s, const char* c, int n);
+void QAbstractTableModel_override_virtual_Index(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_Index(const void* self, int row, int column, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_Sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_Sibling(const void* self, int row, int column, QModelIndex* idx);
+void QAbstractTableModel_override_virtual_DropMimeData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_DropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_Flags(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_Flags(const void* self, QModelIndex* index);
+void QAbstractTableModel_override_virtual_RowCount(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_RowCount(const void* self, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_ColumnCount(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_ColumnCount(const void* self, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_Data(void* self, intptr_t slot);
+QVariant* QAbstractTableModel_virtualbase_Data(const void* self, QModelIndex* index, int role);
+void QAbstractTableModel_override_virtual_SetData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_SetData(void* self, QModelIndex* index, QVariant* value, int role);
+void QAbstractTableModel_override_virtual_HeaderData(void* self, intptr_t slot);
+QVariant* QAbstractTableModel_virtualbase_HeaderData(const void* self, int section, int orientation, int role);
+void QAbstractTableModel_override_virtual_SetHeaderData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_SetHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+void QAbstractTableModel_override_virtual_ItemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractTableModel_virtualbase_ItemData(const void* self, QModelIndex* index);
+void QAbstractTableModel_override_virtual_SetItemData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_SetItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+void QAbstractTableModel_override_virtual_MimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractTableModel_virtualbase_MimeTypes(const void* self);
+void QAbstractTableModel_override_virtual_MimeData(void* self, intptr_t slot);
+QMimeData* QAbstractTableModel_virtualbase_MimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+void QAbstractTableModel_override_virtual_CanDropMimeData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_CanDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_SupportedDropActions(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_SupportedDropActions(const void* self);
+void QAbstractTableModel_override_virtual_SupportedDragActions(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_SupportedDragActions(const void* self);
+void QAbstractTableModel_override_virtual_InsertRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_InsertRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_InsertColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_InsertColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_RemoveRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_RemoveRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_RemoveColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_RemoveColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_MoveRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_MoveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractTableModel_override_virtual_MoveColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_MoveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractTableModel_override_virtual_FetchMore(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_FetchMore(void* self, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_CanFetchMore(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_CanFetchMore(const void* self, QModelIndex* parent);
+void QAbstractTableModel_override_virtual_Sort(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_Sort(void* self, int column, int order);
+void QAbstractTableModel_override_virtual_Buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_Buddy(const void* self, QModelIndex* index);
+void QAbstractTableModel_override_virtual_Match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractTableModel_virtualbase_Match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+void QAbstractTableModel_override_virtual_Span(void* self, intptr_t slot);
+QSize* QAbstractTableModel_virtualbase_Span(const void* self, QModelIndex* index);
+void QAbstractTableModel_override_virtual_RoleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractTableModel_virtualbase_RoleNames(const void* self);
+void QAbstractTableModel_override_virtual_Submit(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_Submit(void* self);
+void QAbstractTableModel_override_virtual_Revert(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_Revert(void* self);
 void QAbstractTableModel_Delete(QAbstractTableModel* self, bool isSubclass);
 
+void QAbstractListModel_new(QAbstractListModel** outptr_QAbstractListModel, QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
+void QAbstractListModel_new2(QObject* parent, QAbstractListModel** outptr_QAbstractListModel, QAbstractItemModel** outptr_QAbstractItemModel, QObject** outptr_QObject);
 QMetaObject* QAbstractListModel_MetaObject(const QAbstractListModel* self);
 void* QAbstractListModel_Metacast(QAbstractListModel* self, const char* param1);
 struct miqt_string QAbstractListModel_Tr(const char* s);
@@ -188,6 +348,68 @@ struct miqt_string QAbstractListModel_Tr2(const char* s, const char* c);
 struct miqt_string QAbstractListModel_Tr3(const char* s, const char* c, int n);
 struct miqt_string QAbstractListModel_TrUtf82(const char* s, const char* c);
 struct miqt_string QAbstractListModel_TrUtf83(const char* s, const char* c, int n);
+void QAbstractListModel_override_virtual_Index(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_Index(const void* self, int row, int column, QModelIndex* parent);
+void QAbstractListModel_override_virtual_Sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_Sibling(const void* self, int row, int column, QModelIndex* idx);
+void QAbstractListModel_override_virtual_DropMimeData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_DropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractListModel_override_virtual_Flags(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_Flags(const void* self, QModelIndex* index);
+void QAbstractListModel_override_virtual_RowCount(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_RowCount(const void* self, QModelIndex* parent);
+void QAbstractListModel_override_virtual_Data(void* self, intptr_t slot);
+QVariant* QAbstractListModel_virtualbase_Data(const void* self, QModelIndex* index, int role);
+void QAbstractListModel_override_virtual_SetData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_SetData(void* self, QModelIndex* index, QVariant* value, int role);
+void QAbstractListModel_override_virtual_HeaderData(void* self, intptr_t slot);
+QVariant* QAbstractListModel_virtualbase_HeaderData(const void* self, int section, int orientation, int role);
+void QAbstractListModel_override_virtual_SetHeaderData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_SetHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+void QAbstractListModel_override_virtual_ItemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractListModel_virtualbase_ItemData(const void* self, QModelIndex* index);
+void QAbstractListModel_override_virtual_SetItemData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_SetItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+void QAbstractListModel_override_virtual_MimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractListModel_virtualbase_MimeTypes(const void* self);
+void QAbstractListModel_override_virtual_MimeData(void* self, intptr_t slot);
+QMimeData* QAbstractListModel_virtualbase_MimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+void QAbstractListModel_override_virtual_CanDropMimeData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_CanDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+void QAbstractListModel_override_virtual_SupportedDropActions(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_SupportedDropActions(const void* self);
+void QAbstractListModel_override_virtual_SupportedDragActions(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_SupportedDragActions(const void* self);
+void QAbstractListModel_override_virtual_InsertRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_InsertRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractListModel_override_virtual_InsertColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_InsertColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractListModel_override_virtual_RemoveRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_RemoveRows(void* self, int row, int count, QModelIndex* parent);
+void QAbstractListModel_override_virtual_RemoveColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_RemoveColumns(void* self, int column, int count, QModelIndex* parent);
+void QAbstractListModel_override_virtual_MoveRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_MoveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractListModel_override_virtual_MoveColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_MoveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+void QAbstractListModel_override_virtual_FetchMore(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_FetchMore(void* self, QModelIndex* parent);
+void QAbstractListModel_override_virtual_CanFetchMore(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_CanFetchMore(const void* self, QModelIndex* parent);
+void QAbstractListModel_override_virtual_Sort(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_Sort(void* self, int column, int order);
+void QAbstractListModel_override_virtual_Buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_Buddy(const void* self, QModelIndex* index);
+void QAbstractListModel_override_virtual_Match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractListModel_virtualbase_Match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+void QAbstractListModel_override_virtual_Span(void* self, intptr_t slot);
+QSize* QAbstractListModel_virtualbase_Span(const void* self, QModelIndex* index);
+void QAbstractListModel_override_virtual_RoleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractListModel_virtualbase_RoleNames(const void* self);
+void QAbstractListModel_override_virtual_Submit(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_Submit(void* self);
+void QAbstractListModel_override_virtual_Revert(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_Revert(void* self);
 void QAbstractListModel_Delete(QAbstractListModel* self, bool isSubclass);
 
 #ifdef __cplusplus