Merge pull request #93 from mappu/miqt-next-1123

Allow subclassing for Qt Model/View classes, and suppress Windows build warnings

.gitignore

@@ -28,6 +28,7 @@ examples/windowsmanifest/windowsmanifest
 examples/uidesigner/uidesigner
 examples/trivialwizard6/trivialwizard6
 examples/subclass/subclass
+examples/modelview/modelview
 examples/libraries/extras-scintillaedit/extras-scintillaedit
 examples/libraries/qt-multimedia/qt-multimedia
 examples/libraries/qt-network/qt-network

cmd/genbindings/clang2il.go

@@ -373,10 +373,6 @@ nextMethod:
 				continue // Skip private/protected
 			}
 
-			if ret.Abstract {
-				continue // The bindings can't construct an abstract class
-			}
-
 			// Check if this is `= delete`
 			if isExplicitlyDeleted(node) {
 				continue

cmd/genbindings/config-allowlist.go

@@ -146,10 +146,10 @@ func AllowClass(className string) bool {
 
 	switch className {
 	case
-		"QTextStreamManipulator",     // Only seems to contain garbage methods
-		"QException",                 // Extends std::exception, too hard
-		"QUnhandledException",        // As above (child class)
-		"QItemSelection",             // Extends a QList<>, too hard
+		"QTextStreamManipulator", // Only seems to contain garbage methods
+		"QException",             // Extends std::exception, too hard
+		"QUnhandledException",    // As above (child class)
+		// "QItemSelection",             // Extends a QList<>, too hard
 		"QXmlStreamAttributes",       // Extends a QList<>, too hard
 		"QPolygon",                   // Extends a QVector<QPoint> template class, too hard
 		"QPolygonF",                  // Extends a QVector<QPoint> template class, too hard
@@ -196,6 +196,44 @@ func AllowVirtual(mm CppMethod) bool {
 	return true // AllowSignal(mm)
 }
 
+func AllowVirtualForClass(className string) bool {
+
+	// Allowing the subclassing of QAccessibleWidget compiles fine,
+	// but, always gives a linker error:
+	//
+	//   /usr/lib/go-1.19/pkg/tool/linux_amd64/link: running g++ failed: exit status 1
+	//   /usr/bin/ld: /tmp/go-link-1745036494/000362.o: in function `MiqtVirtualQAccessibleWidget::MiqtVirtualQAccessibleWidget(QWidget*)':
+	//   undefined reference to `vtable for MiqtVirtualQAccessibleWidget'
+	//
+	// An undefined vtable usually indicates that the virtual class is missing
+	// definitions for some virtual methods, but AFAICT we have complete coverage.
+	if className == "QAccessibleWidget" {
+		return false
+	}
+
+	// Pure virtual method futureInterface() returns an unprojectable template type
+	if className == "QFutureWatcherBase" {
+		return false
+	}
+
+	// Pure virtual dtor (should be possible to support)
+	if className == "QObjectData" {
+		return false
+	}
+
+	if className == "QAccessibleObject" {
+		return false // undefined reference to `vtable for MiqtVirtualQAccessibleObject'
+	}
+
+	// Pure virtual method registerEventNotifier takes a QWinEventNotifier* on Windows
+	// which is platform-specific
+	if className == "QAbstractEventDispatcher" {
+		return false
+	}
+
+	return true
+}
+
 func AllowMethod(className string, mm CppMethod) error {
 
 	for _, p := range mm.Parameters {

cmd/genbindings/emitgo.go

@@ -738,7 +738,10 @@ import "C"
 		// on these types already
 		for _, base := range c.DirectInherits {
 
-			if pkg, ok := KnownClassnames[base]; ok && pkg.PackageName != gfs.currentPackageName {
+			if strings.HasPrefix(base, `QList<`) {
+				ret.WriteString("/* Also inherits unprojectable " + base + " */\n")
+
+			} else if pkg, ok := KnownClassnames[base]; ok && pkg.PackageName != gfs.currentPackageName {
 				// Cross-package parent class
 				ret.WriteString("*" + path.Base(pkg.PackageName) + "." + cabiClassName(base) + "\n")
 				gfs.imports[importPathForQtPackage(pkg.PackageName)] = struct{}{}
@@ -788,12 +791,9 @@ import "C"
 			extraUnsafeArgs += ", h_" + cabiClassName(base) + " unsafe.Pointer"
 		}
 
-		for _, base := range c.DirectInherits {
+		for _, pkg := range c.DirectInheritClassInfo() {
 			ctorPrefix := ""
-			pkg, ok := KnownClassnames[base]
-			if !ok {
-				panic("Class " + c.ClassName + " has unknown parent " + base)
-			}
+			base := pkg.Class.ClassName
 
 			constructRequiresParams := pkg.Class.AllInherits()
 			var ixxParams []string = make([]string, 0, len(constructRequiresParams)+1)
@@ -965,8 +965,9 @@ import "C"
 
 			// Add a package-private function to call the C++ base class method
 			// QWidget_virtualbase_PaintEvent
+			// This is only possible if the function is not pure-virtual
 
-			{
+			if !m.IsPureVirtual {
 				preamble, forwarding := gfs.emitParametersGo2CABIForwarding(m)
 
 				forwarding = "unsafe.Pointer(this.h)" + strings.TrimPrefix(forwarding, `this.h`) // TODO integrate properly
@@ -989,7 +990,10 @@ import "C"
 			{
 
 				var cgoNamedParams []string
-				var paramNames []string = []string{"(&" + goClassName + "{h: self}).callVirtualBase_" + m.SafeMethodName()}
+				var paramNames []string
+				if !m.IsPureVirtual {
+					paramNames = append(paramNames, "(&"+goClassName+"{h: self}).callVirtualBase_"+m.SafeMethodName())
+				}
 				conversion := ""
 
 				if len(m.Parameters) > 0 {
@@ -1009,10 +1013,14 @@ import "C"
 
 				superCbType := `func(` + gfs.emitParametersGo(m.Parameters) + `) ` + m.ReturnType.renderReturnTypeGo(&gfs)
 
-				goCbType := `func(super ` + superCbType
-				if len(m.Parameters) > 0 {
-					goCbType += `, ` + gfs.emitParametersGo(m.Parameters)
+				goCbType := `func(`
+				if !m.IsPureVirtual {
+					goCbType += `super ` + superCbType
+					if len(m.Parameters) > 0 {
+						goCbType += `, `
+					}
 				}
+				goCbType += gfs.emitParametersGo(m.Parameters)
 				goCbType += `) ` + m.ReturnType.renderReturnTypeGo(&gfs)
 
 				ret.WriteString(`func (this *` + goClassName + `) On` + m.SafeMethodName() + `(slot ` + goCbType + `) {

cmd/genbindings/intermediate.go

@@ -413,16 +413,7 @@ func (c *CppClass) VirtualMethods() []CppMethod {
 		return nil
 	}
 
-	// FIXME Allowing the subclassing of QAccessibleWidget compiles fine,
-	// but, always gives a linker error:
-	//
-	//   /usr/lib/go-1.19/pkg/tool/linux_amd64/link: running g++ failed: exit status 1
-	//   /usr/bin/ld: /tmp/go-link-1745036494/000362.o: in function `MiqtVirtualQAccessibleWidget::MiqtVirtualQAccessibleWidget(QWidget*)':
-	//   undefined reference to `vtable for MiqtVirtualQAccessibleWidget'
-	//
-	// An undefined vtable usually indicates that the virtual class is missing
-	// definitions for some virtual methods, but AFAICT we have complete coverage.
-	if c.ClassName == "QAccessibleWidget" {
+	if !AllowVirtualForClass(c.ClassName) {
 		return nil
 	}
 
@@ -444,10 +435,12 @@ func (c *CppClass) VirtualMethods() []CppMethod {
 	// Only allow virtual overrides for direct inherits, not all inherits -
 	// Go will automatically allow virtual overrides for the base type because
 	// the parent struct is nested
-	for _, inh := range c.DirectInherits { // AllInherits() {
-		cinfo, ok := KnownClassnames[inh]
-		if !ok {
-			panic("Class " + c.ClassName + " inherits from unknown class " + inh)
+	for _, cinfo := range c.DirectInheritClassInfo() {
+
+		// If a base class is permanently unprojectable, the child classes
+		// should be too
+		if !AllowVirtualForClass(cinfo.Class.ClassName) {
+			return nil
 		}
 
 		for _, m := range cinfo.Class.Methods {
@@ -500,15 +493,9 @@ func (c *CppClass) AllInherits() []string {
 
 	// FIXME prevent duplicates arising from diamond inheritance
 
-	for _, baseClass := range c.DirectInherits {
+	for _, baseClassInfo := range c.DirectInheritClassInfo() {
 
-		ret = append(ret, baseClass)
-
-		// And everything that class inherits - unless - we've seen it before
-		baseClassInfo, ok := KnownClassnames[baseClass]
-		if !ok {
-			panic("Class " + c.ClassName + " inherits from unknown class " + baseClass)
-		}
+		ret = append(ret, baseClassInfo.Class.ClassName)
 
 		recurseInfo := baseClassInfo.Class.AllInherits()
 		for _, childClass := range recurseInfo {
@@ -519,6 +506,28 @@ func (c *CppClass) AllInherits() []string {
 	return ret
 }
 
+// DirectInheritClassInfo looks up the CppClass for each entry in DirectInherits.
+func (c *CppClass) DirectInheritClassInfo() []lookupResultClass {
+	var ret []lookupResultClass
+
+	for _, inh := range c.DirectInherits { // AllInherits() {
+		cinfo, ok := KnownClassnames[inh]
+		if !ok {
+			if strings.HasPrefix(inh, `QList<`) {
+				// OK, allow this one to slip through
+				// e.g. QItemSelection extends a QList<>
+				continue
+			} else {
+				panic("Class " + c.ClassName + " inherits from unknown class " + inh)
+			}
+		}
+
+		ret = append(ret, cinfo)
+	}
+
+	return ret
+}
+
 type CppTypedef struct {
 	Alias          string
 	UnderlyingType CppParameter

cmd/genbindings/transformblocklist.go

@@ -27,6 +27,12 @@ func astTransformBlocklist(parsed *CppParsedHeader) {
 			continue
 		}
 
+		// If this class is abstract, but we return !AllowVirtualForClass, then
+		// delete its constructors
+		if c.Abstract && !AllowVirtualForClass(c.ClassName) {
+			c.Ctors = nil
+		}
+
 		// Keep
 		parsed.Classes[j] = c
 		j++

cmd/handbindings/binding.go

@@ -2,7 +2,6 @@ package main
 
 /*
 
-#cgo CFLAGS: -fPIC
 #cgo pkg-config: Qt5Widgets
 #include "binding.h"
 

examples/modelview/main.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/mappu/miqt/qt"
+)
+
+func main() {
+	qt.NewQApplication(os.Args)
+
+	model := qt.NewQAbstractListModel()
+
+	model.OnRowCount(func(parent *qt.QModelIndex) int {
+		return 1000
+	})
+
+	model.OnData(func(idx *qt.QModelIndex, role int) *qt.QVariant {
+		if !idx.IsValid() {
+			return qt.NewQVariant()
+		}
+
+		switch qt.ItemDataRole(role) {
+		case qt.DisplayRole:
+			return qt.NewQVariant14(fmt.Sprintf("this is row %d", idx.Row()))
+
+		default:
+			return qt.NewQVariant()
+		}
+	})
+
+	v := qt.NewQListView2()
+	v.SetModel(model.QAbstractItemModel)
+	v.Show()
+
+	qt.QApplication_Exec()
+}

examples/subclass/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"os"
 
 	"github.com/mappu/miqt/qt"
@@ -48,6 +49,12 @@ func main() {
 		w.Update() // repaints in next event loop tick
 	})
 
+	w.OnKeyPressEvent(func(super func(ev *qt.QKeyEvent), ev *qt.QKeyEvent) {
+		super(ev)
+
+		w.SetTitle(fmt.Sprintf("Keypress %d", ev.Key()))
+	})
+
 	w.Show()
 
 	qt.QApplication_Exec()

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/cbor/cflags.go

@@ -2,7 +2,7 @@ package cbor
 
 /*
 #cgo CXXFLAGS: -std=c++11
-#cgo CFLAGS: -std=gnu11 -fPIC
+#cgo CFLAGS: -std=gnu11
 #cgo pkg-config: Qt5Core
 */
 import "C"

qt/cflags.go

@@ -2,7 +2,7 @@ package qt
 
 /*
 #cgo CXXFLAGS: -std=c++11
-#cgo CFLAGS: -std=gnu11 -fPIC
+#cgo CFLAGS: -std=gnu11
 #cgo pkg-config: Qt5Widgets
 */
 import "C"

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);