Initial commit: mozsync, a CLI to export bookmarks from Firefox Sync

Authenticates via the FxA OAuth flow (borrowing Firefox for Android's
public client id) in an embedded, off-the-record Qt6 WebEngine view,
decrypts the Sync 1.5 crypto/keys envelope, and dumps bookmarks as JSON.
Packaged as a flatpak (org.mozsync.App.yml) against io.qt.qtwebengine.BaseApp.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,5 @@
+/mozsync
+/build-dir/
+/.flatpak-builder/
+/.claude/
+*.log

go.mod

@@ -0,0 +1,5 @@
+module mozsync
+
+go 1.27.1
+
+require github.com/mappu/miqt v0.14.0

go.sum

@@ -0,0 +1,2 @@
+github.com/mappu/miqt v0.14.0 h1:PPP3TBREc79Ei/sMous6rN+z6s7Y6pq5U+NsljtvVfg=
+github.com/mappu/miqt v0.14.0/go.mod h1:xFg7ADaO1QSkmXPsPODoKe/bydJpRG9fgCYyIDl/h1U=

main.go

@@ -0,0 +1,626 @@
+package main
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/ecdh"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/mappu/miqt/qt6"
+	"github.com/mappu/miqt/qt6/webengine"
+)
+
+// Borrows Firefox for Android's public OAuth client id, unlike Firefox
+// Desktop's client which only works inside browser chrome.
+//
+// This client's registered redirect_uri used to be a real hosted page at
+// lockbox.firefox.com that kept the auth code visible in the address bar.
+// Mozilla discontinued the Lockwise app in Dec 2021 and that page now 301s
+// straight to a marketing page, dropping the ?code=/&state= query string in
+// the process - and since the redirect_uri is baked into this client id's
+// registration, we can't just point it somewhere we control.
+//
+// So doLogin() opens the auth page in an embedded, off-the-record
+// QWebEngineView (Qt6 WebEngine, via the miqt bindings) with a URL request
+// interceptor watching for redirectHost. When that request is about to go
+// out, we block it before it ever hits the network, read the code/state off
+// its URL, and quit the Qt event loop - no fake TLS cert, no browser
+// warning, no external browser process at all.
+const (
+	clientID       = "e7ce535d93522896"
+	scope          = "https://identity.mozilla.com/apps/oldsync"
+	authURL        = "https://accounts.firefox.com/authorization"
+	tokenURL       = "https://oauth.accounts.firefox.com/v1/token"
+	tokenServerURL = "https://token.services.mozilla.com/1.0/sync/1.5"
+	redirectHost   = "lockbox.firefox.com"
+)
+
+type credentials struct {
+	RefreshToken string `json:"refresh_token"`
+	KeyID        string `json:"key_id"`
+	SyncKey      string `json:"sync_key_b64"` // base64url of the 64-byte oldsync scoped key
+}
+
+func credentialsPath() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".config", "mozsync", "credentials.json")
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "usage: mozsync <login|dump>")
+		os.Exit(1)
+	}
+	var err error
+	switch os.Args[1] {
+	case "login":
+		err = doLogin()
+	case "dump":
+		err = doDump()
+	default:
+		fmt.Fprintln(os.Stderr, "usage: mozsync <login|dump>")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error:", err)
+		os.Exit(1)
+	}
+}
+
+// ---------- login (one-time browser-based OAuth setup) ----------
+
+func doLogin() error {
+	verifier := randB64URL(32)
+	challenge := b64url(sha256sum([]byte(verifier)))
+	state := randB64URL(16)
+
+	priv, err := ecdh.P256().GenerateKey(rand.Reader)
+	if err != nil {
+		return err
+	}
+	pub := priv.PublicKey().Bytes() // uncompressed point: 0x04 || X(32) || Y(32)
+	x, y := pub[1:33], pub[33:65]
+	jwk := map[string]string{"crv": "P-256", "kty": "EC", "x": b64url(x), "y": b64url(y)}
+	jwkJSON, err := json.Marshal(jwk)
+	if err != nil {
+		return err
+	}
+
+	q := url.Values{}
+	q.Set("client_id", clientID)
+	q.Set("scope", scope)
+	q.Set("state", state)
+	q.Set("access_type", "offline")
+	q.Set("code_challenge_method", "S256")
+	q.Set("code_challenge", challenge)
+	q.Set("keys_jwk", b64url(jwkJSON))
+	q.Set("response_type", "code")
+	fullAuthURL := authURL + "?" + q.Encode()
+
+	code, gotState, err := runLoginWindow(fullAuthURL)
+	if err != nil {
+		return err
+	}
+	if code == "" {
+		return fmt.Errorf("login window closed before signing in")
+	}
+	if gotState != state {
+		return fmt.Errorf("state mismatch (got %q, want %q) - aborting", gotState, state)
+	}
+
+	var tokenResp struct {
+		AccessToken  string `json:"access_token"`
+		RefreshToken string `json:"refresh_token"`
+		KeysJWE      string `json:"keys_jwe"`
+	}
+	err = postJSON(tokenURL, map[string]string{
+		"client_id":     clientID,
+		"grant_type":    "authorization_code",
+		"code":          code,
+		"code_verifier": verifier,
+	}, &tokenResp)
+	if err != nil {
+		return fmt.Errorf("token exchange failed: %w", err)
+	}
+	if tokenResp.KeysJWE == "" {
+		return fmt.Errorf("no keys_jwe in token response")
+	}
+
+	kid, kBytes, err := decryptKeysJWE(tokenResp.KeysJWE, priv)
+	if err != nil {
+		return fmt.Errorf("decrypting keys_jwe: %w", err)
+	}
+
+	creds := credentials{RefreshToken: tokenResp.RefreshToken, KeyID: kid, SyncKey: b64url(kBytes)}
+	if err := saveCredentials(creds); err != nil {
+		return err
+	}
+	fmt.Println()
+	fmt.Println("Saved credentials to", credentialsPath())
+	fmt.Println("This file grants ongoing access to your Mozilla account's sync data - keep it private (mode 0600).")
+	fmt.Println("Run `mozsync dump` to fetch your bookmarks.")
+	return nil
+}
+
+// ---------- embedded login window ----------
+//
+// runLoginWindow opens fullAuthURL in an off-the-record QWebEngineView and
+// watches every outgoing request with a QWebEngineUrlRequestInterceptor.
+// When one targets redirectHost, we block it (so it never actually hits
+// Mozilla's broken redirect endpoint) and read code/state straight off its
+// URL. Interception runs on Chromium's IO thread, not the Qt GUI thread, so
+// the interceptor callback only ever touches a mutex-guarded plain Go value
+// - a QTimer polling on the GUI thread is what actually calls
+// QCoreApplication_Quit() once a result shows up.
+func runLoginWindow(fullAuthURL string) (code, state string, err error) {
+	app := qt6.NewQApplication(os.Args)
+	defer app.Delete()
+
+	var (
+		mu     sync.Mutex
+		result *struct{ code, state string }
+	)
+
+	profile := webengine.NewQWebEngineProfile() // no name -> off-the-record, nothing persisted
+	interceptor := webengine.NewQWebEngineUrlRequestInterceptor()
+	interceptor.OnInterceptRequest(func(info *webengine.QWebEngineUrlRequestInfo) {
+		u := info.RequestUrl()
+		if u.Host() != redirectHost {
+			return
+		}
+		info.Block(true)
+		vals, _ := url.ParseQuery(u.Query())
+		mu.Lock()
+		if result == nil {
+			result = &struct{ code, state string }{vals.Get("code"), vals.Get("state")}
+		}
+		mu.Unlock()
+	})
+	profile.SetUrlRequestInterceptor(interceptor)
+
+	view := webengine.NewQWebEngineView3(profile)
+	view.SetWindowTitle("Sign in to your Mozilla Account")
+	view.Resize(900, 700)
+	view.Load(qt6.NewQUrl3(fullAuthURL))
+	view.Show()
+
+	const timeout = 5 * time.Minute
+	deadline := time.Now().Add(timeout)
+	poll := qt6.NewQTimer()
+	poll.OnTimeout(func() {
+		mu.Lock()
+		r := result
+		mu.Unlock()
+		if r != nil || time.Now().After(deadline) {
+			qt6.QCoreApplication_Quit()
+		}
+	})
+	poll.Start(150)
+
+	qt6.QCoreApplication_Exec() // blocks until Quit(); also returns if the user closes the window
+
+	mu.Lock()
+	defer mu.Unlock()
+	if result == nil {
+		return "", "", nil // window closed / timed out without a captured redirect
+	}
+	return result.code, result.state, nil
+}
+
+func saveCredentials(c credentials) error {
+	path := credentialsPath()
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(c, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, data, 0o600)
+}
+
+func loadCredentials() (credentials, error) {
+	var c credentials
+	data, err := os.ReadFile(credentialsPath())
+	if err != nil {
+		return c, err
+	}
+	err = json.Unmarshal(data, &c)
+	return c, err
+}
+
+// ---------- JWE (ECDH-ES + A256GCM), per RFC 7518 4.6 ----------
+
+func decryptKeysJWE(jwe string, priv *ecdh.PrivateKey) (kid string, key []byte, err error) {
+	parts := strings.Split(jwe, ".")
+	if len(parts) != 5 {
+		return "", nil, fmt.Errorf("malformed JWE: expected 5 segments, got %d", len(parts))
+	}
+	headerB64, ivB64, ctB64, tagB64 := parts[0], parts[2], parts[3], parts[4]
+
+	headerRaw, err := base64.RawURLEncoding.DecodeString(headerB64)
+	if err != nil {
+		return "", nil, err
+	}
+	var header struct {
+		Enc string `json:"enc"`
+		Alg string `json:"alg"`
+		EPK struct {
+			X string `json:"x"`
+			Y string `json:"y"`
+		} `json:"epk"`
+	}
+	if err := json.Unmarshal(headerRaw, &header); err != nil {
+		return "", nil, err
+	}
+	if header.Alg != "ECDH-ES" || header.Enc != "A256GCM" {
+		return "", nil, fmt.Errorf("unexpected JWE alg/enc: %s/%s", header.Alg, header.Enc)
+	}
+
+	epkX, err := base64.RawURLEncoding.DecodeString(header.EPK.X)
+	if err != nil {
+		return "", nil, err
+	}
+	epkY, err := base64.RawURLEncoding.DecodeString(header.EPK.Y)
+	if err != nil {
+		return "", nil, err
+	}
+	epkBytes := append([]byte{0x04}, append(epkX, epkY...)...)
+	serverPub, err := ecdh.P256().NewPublicKey(epkBytes)
+	if err != nil {
+		return "", nil, err
+	}
+	shared, err := priv.ECDH(serverPub)
+	if err != nil {
+		return "", nil, err
+	}
+
+	cek := concatKDF(shared, header.Enc, 32) // A256GCM -> 256-bit CEK
+
+	iv, err := base64.RawURLEncoding.DecodeString(ivB64)
+	if err != nil {
+		return "", nil, err
+	}
+	ciphertext, err := base64.RawURLEncoding.DecodeString(ctB64)
+	if err != nil {
+		return "", nil, err
+	}
+	tag, err := base64.RawURLEncoding.DecodeString(tagB64)
+	if err != nil {
+		return "", nil, err
+	}
+
+	block, err := aes.NewCipher(cek)
+	if err != nil {
+		return "", nil, err
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", nil, err
+	}
+	aad := []byte(headerB64) // JWE AAD is the raw base64url header segment itself
+	plaintext, err := gcm.Open(nil, iv, append(ciphertext, tag...), aad)
+	if err != nil {
+		return "", nil, fmt.Errorf("GCM open failed: %w", err)
+	}
+
+	var scoped map[string]struct {
+		K   string `json:"k"`
+		Kid string `json:"kid"`
+	}
+	if err := json.Unmarshal(plaintext, &scoped); err != nil {
+		return "", nil, err
+	}
+	sk, ok := scoped[scope]
+	if !ok {
+		return "", nil, fmt.Errorf("no scoped key for %s in keys_jwe payload", scope)
+	}
+	kBytes, err := base64.RawURLEncoding.DecodeString(sk.K)
+	if err != nil {
+		return "", nil, err
+	}
+	return sk.Kid, kBytes, nil
+}
+
+// concatKDF is the single-round NIST SP 800-56A Concat KDF used by JWE ECDH-ES
+// direct agreement, with empty PartyUInfo/PartyVInfo (no apu/apv exchanged here).
+func concatKDF(z []byte, algID string, keyLenBytes int) []byte {
+	algIDBytes := []byte(algID)
+	otherInfo := appendUint32(nil, uint32(len(algIDBytes)))
+	otherInfo = append(otherInfo, algIDBytes...)
+	otherInfo = appendUint32(otherInfo, 0) // PartyUInfo length (empty)
+	otherInfo = appendUint32(otherInfo, 0) // PartyVInfo length (empty)
+	otherInfo = appendUint32(otherInfo, uint32(keyLenBytes*8))
+
+	h := sha256.New()
+	h.Write(appendUint32(nil, 1)) // round counter; one round covers 256 bits
+	h.Write(z)
+	h.Write(otherInfo)
+	sum := h.Sum(nil)
+	return sum[:keyLenBytes]
+}
+
+func appendUint32(b []byte, v uint32) []byte {
+	return append(b, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+// ---------- Sync 1.5 storage records ----------
+
+type syncKeyBundle struct {
+	EncKey  []byte
+	HMACKey []byte
+}
+
+func decryptBSOPayload(payloadJSON string, bundle syncKeyBundle) ([]byte, error) {
+	var payload struct {
+		Ciphertext string `json:"ciphertext"`
+		IV         string `json:"IV"`
+		HMAC       string `json:"hmac"`
+	}
+	if err := json.Unmarshal([]byte(payloadJSON), &payload); err != nil {
+		return nil, err
+	}
+	mac := hmac.New(sha256.New, bundle.HMACKey)
+	mac.Write([]byte(payload.Ciphertext)) // HMAC covers the base64 ciphertext string itself
+	if hex.EncodeToString(mac.Sum(nil)) != payload.HMAC {
+		return nil, fmt.Errorf("HMAC verification failed")
+	}
+	iv, err := base64.StdEncoding.DecodeString(payload.IV)
+	if err != nil {
+		return nil, err
+	}
+	ct, err := base64.StdEncoding.DecodeString(payload.Ciphertext)
+	if err != nil {
+		return nil, err
+	}
+	if len(ct)%aes.BlockSize != 0 {
+		return nil, fmt.Errorf("ciphertext not a multiple of block size")
+	}
+	block, err := aes.NewCipher(bundle.EncKey)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]byte, len(ct))
+	cipher.NewCBCDecrypter(block, iv).CryptBlocks(out, ct)
+	return pkcs7Unpad(out)
+}
+
+func pkcs7Unpad(b []byte) ([]byte, error) {
+	if len(b) == 0 {
+		return nil, fmt.Errorf("empty plaintext")
+	}
+	pad := int(b[len(b)-1])
+	if pad == 0 || pad > len(b) {
+		return nil, fmt.Errorf("invalid padding")
+	}
+	return b[:len(b)-pad], nil
+}
+
+func doDump() error {
+	creds, err := loadCredentials()
+	if err != nil {
+		return fmt.Errorf("no credentials found, run `mozsync login` first: %w", err)
+	}
+	masterKey, err := base64.RawURLEncoding.DecodeString(creds.SyncKey)
+	if err != nil || len(masterKey) != 64 {
+		return fmt.Errorf("stored sync key is invalid, re-run `mozsync login`")
+	}
+	masterBundle := syncKeyBundle{EncKey: masterKey[:32], HMACKey: masterKey[32:64]}
+
+	accessToken, err := refreshAccessToken(creds.RefreshToken)
+	if err != nil {
+		return fmt.Errorf("refreshing access token: %w", err)
+	}
+	hawkID, hawkKey, apiEndpoint, err := getStorageCredentials(accessToken, creds.KeyID)
+	if err != nil {
+		return fmt.Errorf("fetching storage credentials: %w", err)
+	}
+
+	keysPayload, err := storageGET(apiEndpoint, "/storage/crypto/keys", hawkID, hawkKey)
+	if err != nil {
+		return fmt.Errorf("fetching crypto/keys: %w", err)
+	}
+	var keysBSO struct {
+		Payload string `json:"payload"`
+	}
+	if err := json.Unmarshal(keysPayload, &keysBSO); err != nil {
+		return err
+	}
+	plain, err := decryptBSOPayload(keysBSO.Payload, masterBundle)
+	if err != nil {
+		return fmt.Errorf("decrypting crypto/keys: %w", err)
+	}
+	var keysRecord struct {
+		Default     []string            `json:"default"`
+		Collections map[string][]string `json:"collections"`
+	}
+	if err := json.Unmarshal(plain, &keysRecord); err != nil {
+		return err
+	}
+	bundleFor := func(collection string) (syncKeyBundle, error) {
+		pair := keysRecord.Default
+		if override, ok := keysRecord.Collections[collection]; ok {
+			pair = override
+		}
+		if len(pair) != 2 {
+			return syncKeyBundle{}, fmt.Errorf("no usable key bundle for collection %s", collection)
+		}
+		enc, err := base64.StdEncoding.DecodeString(pair[0])
+		if err != nil {
+			return syncKeyBundle{}, err
+		}
+		h, err := base64.StdEncoding.DecodeString(pair[1])
+		if err != nil {
+			return syncKeyBundle{}, err
+		}
+		return syncKeyBundle{EncKey: enc, HMACKey: h}, nil
+	}
+	bmBundle, err := bundleFor("bookmarks")
+	if err != nil {
+		return err
+	}
+
+	bmRaw, err := storageGET(apiEndpoint, "/storage/bookmarks?full=true", hawkID, hawkKey)
+	if err != nil {
+		return fmt.Errorf("fetching bookmarks: %w", err)
+	}
+	var bsos []struct {
+		ID      string `json:"id"`
+		Payload string `json:"payload"`
+	}
+	if err := json.Unmarshal(bmRaw, &bsos); err != nil {
+		return err
+	}
+
+	var records []json.RawMessage
+	for _, bso := range bsos {
+		plain, err := decryptBSOPayload(bso.Payload, bmBundle)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "warning: skipping record %s: %v\n", bso.ID, err)
+			continue
+		}
+		records = append(records, json.RawMessage(plain))
+	}
+
+	out, err := json.MarshalIndent(records, "", "  ")
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	return nil
+}
+
+func refreshAccessToken(refreshToken string) (string, error) {
+	var resp struct {
+		AccessToken string `json:"access_token"`
+	}
+	err := postJSON(tokenURL, map[string]string{
+		"client_id":     clientID,
+		"grant_type":    "refresh_token",
+		"refresh_token": refreshToken,
+		"scope":         scope,
+	}, &resp)
+	if err != nil {
+		return "", err
+	}
+	if resp.AccessToken == "" {
+		return "", fmt.Errorf("empty access token in refresh response")
+	}
+	return resp.AccessToken, nil
+}
+
+func getStorageCredentials(accessToken, keyID string) (id, key, apiEndpoint string, err error) {
+	req, err := http.NewRequest("GET", tokenServerURL, nil)
+	if err != nil {
+		return "", "", "", err
+	}
+	req.Header.Set("Authorization", "Bearer "+accessToken)
+	req.Header.Set("X-KeyID", keyID)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", "", "", err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return "", "", "", fmt.Errorf("tokenserver returned %d: %s", resp.StatusCode, body)
+	}
+	var ts struct {
+		ID          string `json:"id"`
+		Key         string `json:"key"`
+		APIEndpoint string `json:"api_endpoint"`
+	}
+	if err := json.Unmarshal(body, &ts); err != nil {
+		return "", "", "", err
+	}
+	return ts.ID, ts.Key, ts.APIEndpoint, nil
+}
+
+func storageGET(apiEndpoint, path, hawkID, hawkKey string) ([]byte, error) {
+	fullURL := apiEndpoint + path
+	req, err := http.NewRequest("GET", fullURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", hawkHeader("GET", fullURL, hawkID, hawkKey))
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("storage server returned %d: %s", resp.StatusCode, body)
+	}
+	return body, nil
+}
+
+// ---------- Hawk request signing ----------
+
+func hawkHeader(method, rawURL, id, key string) string {
+	u, _ := url.Parse(rawURL)
+	ts := time.Now().Unix()
+	nonce := randB64URL(6)
+	resource := u.Path
+	if u.RawQuery != "" {
+		resource += "?" + u.RawQuery
+	}
+	port := u.Port()
+	if port == "" {
+		port = "443"
+	}
+	normalized := fmt.Sprintf("hawk.1.header\n%d\n%s\n%s\n%s\n%s\n%s\n\n\n",
+		ts, nonce, method, resource, u.Hostname(), port)
+	mac := hmac.New(sha256.New, []byte(key))
+	mac.Write([]byte(normalized))
+	macB64 := base64.StdEncoding.EncodeToString(mac.Sum(nil))
+	return fmt.Sprintf(`Hawk id="%s", ts="%d", nonce="%s", mac="%s"`, id, ts, nonce, macB64)
+}
+
+// ---------- small helpers ----------
+
+func postJSON(u string, body interface{}, out interface{}) error {
+	data, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	resp, err := http.Post(u, "application/json", strings.NewReader(string(data)))
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	respBody, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("HTTP %d: %s", resp.StatusCode, respBody)
+	}
+	return json.Unmarshal(respBody, out)
+}
+
+func randB64URL(n int) string {
+	b := make([]byte, n)
+	_, _ = rand.Read(b)
+	return b64url(b)
+}
+
+func b64url(b []byte) string {
+	return base64.RawURLEncoding.EncodeToString(b)
+}
+
+func sha256sum(b []byte) []byte {
+	s := sha256.Sum256(b)
+	return s[:]
+}

org.mozsync.App.yml

@@ -0,0 +1,34 @@
+app-id: org.mozsync.App
+runtime: org.kde.Platform
+runtime-version: "6.11"
+sdk: org.kde.Sdk
+base: io.qt.qtwebengine.BaseApp
+base-version: "6.11"
+command: mozsync
+
+sdk-extensions:
+  - org.freedesktop.Sdk.Extension.golang
+
+finish-args:
+  - --share=network
+  - --socket=wayland
+  - --socket=fallback-x11
+  - --device=dri
+
+build-options:
+  append-path: /usr/lib/sdk/golang/bin
+  env:
+    GOFLAGS: -mod=vendor
+    GOCACHE: /run/build/mozsync/.gocache
+    CGO_ENABLED: "1"
+    PKG_CONFIG_PATH: /app/lib/x86_64-linux-gnu/pkgconfig:/app/lib/pkgconfig:/usr/lib/x86_64-linux-gnu/pkgconfig:/usr/lib/pkgconfig
+
+modules:
+  - name: mozsync
+    buildsystem: simple
+    build-commands:
+      - go build -o mozsync .
+      - install -Dm755 mozsync /app/bin/mozsync
+    sources:
+      - type: dir
+        path: .

vendor/github.com/mappu/miqt/COPYING

@@ -0,0 +1,19 @@
+Copyright 2024 - 2025, mappu
+Copyright 2025 - 2025, The MIQT developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in the
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/mappu/miqt/libmiqt/libmiqt.go

@@ -0,0 +1,10 @@
+package libmiqt
+
+// SPDX-License-Identifier: MIT
+
+/*
+
+#include "libmiqt.h"
+
+*/
+import "C"

vendor/github.com/mappu/miqt/libmiqt/libmiqt.h

@@ -0,0 +1,33 @@
+#pragma once
+#ifndef MIQT_LIBMIQT_LIBMIQT_H
+#define MIQT_LIBMIQT_LIBMIQT_H
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct miqt_string {
+    size_t len;
+    char* data;
+};
+
+struct miqt_array {
+    size_t len;
+    void* data;
+};
+
+struct miqt_map {
+    size_t len;
+    void* keys;
+    void* values;
+};
+
+typedef const char const_char;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/binding.go

@@ -0,0 +1 @@
+package qt6

vendor/github.com/mappu/miqt/qt6/cflags.go

@@ -0,0 +1,10 @@
+package qt6
+
+/*
+#cgo pkg-config: Qt6Widgets
+*/
+import "C"
+
+import (
+	_ "github.com/mappu/miqt/libmiqt"
+)

vendor/github.com/mappu/miqt/qt6/cflags_windowsqtstatic.cpp

@@ -0,0 +1,12 @@
+#ifdef MIQT_WINDOWSQTSTATIC
+
+#include <QtPlugin>
+Q_IMPORT_PLUGIN (QWindowsIntegrationPlugin);
+
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+  Q_IMPORT_PLUGIN (QModernWindowsStylePlugin);
+#else
+  Q_IMPORT_PLUGIN (QWindowsVistaStylePlugin);
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/cflags_windowsqtstatic.go

@@ -0,0 +1,12 @@
+//go:build windowsqtstatic
+// +build windowsqtstatic
+
+package qt6
+
+// Statically link the Qt platform plugins
+
+/*
+#cgo windowsqtstatic CXXFLAGS: -DMIQT_WINDOWSQTSTATIC
+#cgo pkg-config: --static Qt6Widgets
+*/
+import "C"

vendor/github.com/mappu/miqt/qt6/gen_qabstractanimation.h

@@ -0,0 +1,163 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTANIMATION_H
+#define MIQT_QT6_GEN_QABSTRACTANIMATION_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractAnimation;
+class QAnimationDriver;
+class QAnimationGroup;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+#else
+typedef struct QAbstractAnimation QAbstractAnimation;
+typedef struct QAnimationDriver QAnimationDriver;
+typedef struct QAnimationGroup QAnimationGroup;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QAbstractAnimation* QAbstractAnimation_new();
+QAbstractAnimation* QAbstractAnimation_new2(QObject* parent);
+void QAbstractAnimation_virtbase(QAbstractAnimation* src, 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);
+int QAbstractAnimation_state(const QAbstractAnimation* self);
+QAnimationGroup* QAbstractAnimation_group(const QAbstractAnimation* self);
+int QAbstractAnimation_direction(const QAbstractAnimation* self);
+void QAbstractAnimation_setDirection(QAbstractAnimation* self, int direction);
+int QAbstractAnimation_currentTime(const QAbstractAnimation* self);
+int QAbstractAnimation_currentLoopTime(const QAbstractAnimation* self);
+int QAbstractAnimation_loopCount(const QAbstractAnimation* self);
+void QAbstractAnimation_setLoopCount(QAbstractAnimation* self, int loopCount);
+int QAbstractAnimation_currentLoop(const QAbstractAnimation* self);
+int QAbstractAnimation_duration(const QAbstractAnimation* self);
+int QAbstractAnimation_totalDuration(const QAbstractAnimation* self);
+void QAbstractAnimation_finished(QAbstractAnimation* self);
+void QAbstractAnimation_connect_finished(QAbstractAnimation* self, intptr_t slot);
+void QAbstractAnimation_stateChanged(QAbstractAnimation* self, int newState, int oldState);
+void QAbstractAnimation_connect_stateChanged(QAbstractAnimation* self, intptr_t slot);
+void QAbstractAnimation_currentLoopChanged(QAbstractAnimation* self, int currentLoop);
+void QAbstractAnimation_connect_currentLoopChanged(QAbstractAnimation* self, intptr_t slot);
+void QAbstractAnimation_directionChanged(QAbstractAnimation* self, int param1);
+void QAbstractAnimation_connect_directionChanged(QAbstractAnimation* self, intptr_t slot);
+void QAbstractAnimation_start(QAbstractAnimation* self);
+void QAbstractAnimation_pause(QAbstractAnimation* self);
+void QAbstractAnimation_resume(QAbstractAnimation* self);
+void QAbstractAnimation_setPaused(QAbstractAnimation* self, bool paused);
+void QAbstractAnimation_stop(QAbstractAnimation* self);
+void QAbstractAnimation_setCurrentTime(QAbstractAnimation* self, int msecs);
+bool QAbstractAnimation_event(QAbstractAnimation* self, QEvent* event);
+void QAbstractAnimation_updateCurrentTime(QAbstractAnimation* self, int currentTime);
+void QAbstractAnimation_updateState(QAbstractAnimation* self, int newState, int oldState);
+void QAbstractAnimation_updateDirection(QAbstractAnimation* self, int direction);
+struct miqt_string QAbstractAnimation_tr2(const char* s, const char* c);
+struct miqt_string QAbstractAnimation_tr3(const char* s, const char* c, int n);
+void QAbstractAnimation_startWithPolicy(QAbstractAnimation* self, int policy);
+
+bool QAbstractAnimation_override_virtual_duration(void* self, intptr_t slot);
+int QAbstractAnimation_virtualbase_duration(const void* self);
+bool QAbstractAnimation_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractAnimation_virtualbase_event(void* self, QEvent* event);
+bool QAbstractAnimation_override_virtual_updateCurrentTime(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_updateCurrentTime(void* self, int currentTime);
+bool QAbstractAnimation_override_virtual_updateState(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_updateState(void* self, int newState, int oldState);
+bool QAbstractAnimation_override_virtual_updateDirection(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_updateDirection(void* self, int direction);
+bool QAbstractAnimation_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractAnimation_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractAnimation_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractAnimation_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractAnimation_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractAnimation_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractAnimation_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractAnimation_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAbstractAnimation_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractAnimation_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractAnimation_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractAnimation_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractAnimation_delete(QAbstractAnimation* self);
+
+QAnimationDriver* QAnimationDriver_new();
+QAnimationDriver* QAnimationDriver_new2(QObject* parent);
+void QAnimationDriver_virtbase(QAnimationDriver* src, QObject** outptr_QObject);
+QMetaObject* QAnimationDriver_metaObject(const QAnimationDriver* self);
+void* QAnimationDriver_metacast(QAnimationDriver* self, const char* param1);
+struct miqt_string QAnimationDriver_tr(const char* s);
+void QAnimationDriver_advance(QAnimationDriver* self);
+void QAnimationDriver_install(QAnimationDriver* self);
+void QAnimationDriver_uninstall(QAnimationDriver* self);
+bool QAnimationDriver_isRunning(const QAnimationDriver* self);
+long long QAnimationDriver_elapsed(const QAnimationDriver* self);
+void QAnimationDriver_started(QAnimationDriver* self);
+void QAnimationDriver_connect_started(QAnimationDriver* self, intptr_t slot);
+void QAnimationDriver_stopped(QAnimationDriver* self);
+void QAnimationDriver_connect_stopped(QAnimationDriver* self, intptr_t slot);
+void QAnimationDriver_start(QAnimationDriver* self);
+void QAnimationDriver_stop(QAnimationDriver* self);
+struct miqt_string QAnimationDriver_tr2(const char* s, const char* c);
+struct miqt_string QAnimationDriver_tr3(const char* s, const char* c, int n);
+
+bool QAnimationDriver_override_virtual_advance(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_advance(void* self);
+bool QAnimationDriver_override_virtual_elapsed(void* self, intptr_t slot);
+long long QAnimationDriver_virtualbase_elapsed(const void* self);
+bool QAnimationDriver_override_virtual_start(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_start(void* self);
+bool QAnimationDriver_override_virtual_stop(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_stop(void* self);
+bool QAnimationDriver_override_virtual_event(void* self, intptr_t slot);
+bool QAnimationDriver_virtualbase_event(void* self, QEvent* event);
+bool QAnimationDriver_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAnimationDriver_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAnimationDriver_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAnimationDriver_override_virtual_childEvent(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAnimationDriver_override_virtual_customEvent(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_customEvent(void* self, QEvent* event);
+bool QAnimationDriver_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAnimationDriver_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAnimationDriver_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QAnimationDriver_protectedbase_advanceAnimation(bool* _dynamic_cast_ok, void* self);
+QObject* QAnimationDriver_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAnimationDriver_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAnimationDriver_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAnimationDriver_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAnimationDriver_delete(QAnimationDriver* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractbutton.h

@@ -0,0 +1,269 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTBUTTON_H
+#define MIQT_QT6_GEN_QABSTRACTBUTTON_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractButton;
+class QActionEvent;
+class QButtonGroup;
+class QChildEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
+class QEnterEvent;
+class QEvent;
+class QFocusEvent;
+class QHideEvent;
+class QIcon;
+class QInputMethodEvent;
+class QKeyEvent;
+class QKeySequence;
+class QMetaMethod;
+class QMetaObject;
+class QMouseEvent;
+class QMoveEvent;
+class QObject;
+class QPaintDevice;
+class QPaintEngine;
+class QPaintEvent;
+class QPainter;
+class QPoint;
+class QResizeEvent;
+class QShowEvent;
+class QSize;
+class QTabletEvent;
+class QTimerEvent;
+class QVariant;
+class QWheelEvent;
+class QWidget;
+#else
+typedef struct QAbstractButton QAbstractButton;
+typedef struct QActionEvent QActionEvent;
+typedef struct QButtonGroup QButtonGroup;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
+typedef struct QEnterEvent QEnterEvent;
+typedef struct QEvent QEvent;
+typedef struct QFocusEvent QFocusEvent;
+typedef struct QHideEvent QHideEvent;
+typedef struct QIcon QIcon;
+typedef struct QInputMethodEvent QInputMethodEvent;
+typedef struct QKeyEvent QKeyEvent;
+typedef struct QKeySequence QKeySequence;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
+typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
+typedef struct QPoint QPoint;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QShowEvent QShowEvent;
+typedef struct QSize QSize;
+typedef struct QTabletEvent QTabletEvent;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractButton* QAbstractButton_new(QWidget* parent);
+QAbstractButton* QAbstractButton_new2();
+void QAbstractButton_virtbase(QAbstractButton* src, QWidget** outptr_QWidget);
+QMetaObject* QAbstractButton_metaObject(const QAbstractButton* self);
+void* QAbstractButton_metacast(QAbstractButton* self, const char* param1);
+struct miqt_string QAbstractButton_tr(const char* s);
+void QAbstractButton_setText(QAbstractButton* self, struct miqt_string text);
+struct miqt_string QAbstractButton_text(const QAbstractButton* self);
+void QAbstractButton_setIcon(QAbstractButton* self, QIcon* icon);
+QIcon* QAbstractButton_icon(const QAbstractButton* self);
+QSize* QAbstractButton_iconSize(const QAbstractButton* self);
+void QAbstractButton_setShortcut(QAbstractButton* self, QKeySequence* key);
+QKeySequence* QAbstractButton_shortcut(const QAbstractButton* self);
+void QAbstractButton_setCheckable(QAbstractButton* self, bool checkable);
+bool QAbstractButton_isCheckable(const QAbstractButton* self);
+bool QAbstractButton_isChecked(const QAbstractButton* self);
+void QAbstractButton_setDown(QAbstractButton* self, bool down);
+bool QAbstractButton_isDown(const QAbstractButton* self);
+void QAbstractButton_setAutoRepeat(QAbstractButton* self, bool autoRepeat);
+bool QAbstractButton_autoRepeat(const QAbstractButton* self);
+void QAbstractButton_setAutoRepeatDelay(QAbstractButton* self, int autoRepeatDelay);
+int QAbstractButton_autoRepeatDelay(const QAbstractButton* self);
+void QAbstractButton_setAutoRepeatInterval(QAbstractButton* self, int autoRepeatInterval);
+int QAbstractButton_autoRepeatInterval(const QAbstractButton* self);
+void QAbstractButton_setAutoExclusive(QAbstractButton* self, bool autoExclusive);
+bool QAbstractButton_autoExclusive(const QAbstractButton* self);
+QButtonGroup* QAbstractButton_group(const QAbstractButton* self);
+void QAbstractButton_setIconSize(QAbstractButton* self, QSize* size);
+void QAbstractButton_animateClick(QAbstractButton* self);
+void QAbstractButton_click(QAbstractButton* self);
+void QAbstractButton_toggle(QAbstractButton* self);
+void QAbstractButton_setChecked(QAbstractButton* self, bool checked);
+void QAbstractButton_pressed(QAbstractButton* self);
+void QAbstractButton_connect_pressed(QAbstractButton* self, intptr_t slot);
+void QAbstractButton_released(QAbstractButton* self);
+void QAbstractButton_connect_released(QAbstractButton* self, intptr_t slot);
+void QAbstractButton_clicked(QAbstractButton* self);
+void QAbstractButton_connect_clicked(QAbstractButton* self, intptr_t slot);
+void QAbstractButton_toggled(QAbstractButton* self, bool checked);
+void QAbstractButton_connect_toggled(QAbstractButton* self, intptr_t slot);
+void QAbstractButton_paintEvent(QAbstractButton* self, QPaintEvent* e);
+bool QAbstractButton_hitButton(const QAbstractButton* self, QPoint* pos);
+void QAbstractButton_checkStateSet(QAbstractButton* self);
+void QAbstractButton_nextCheckState(QAbstractButton* self);
+bool QAbstractButton_event(QAbstractButton* self, QEvent* e);
+void QAbstractButton_keyPressEvent(QAbstractButton* self, QKeyEvent* e);
+void QAbstractButton_keyReleaseEvent(QAbstractButton* self, QKeyEvent* e);
+void QAbstractButton_mousePressEvent(QAbstractButton* self, QMouseEvent* e);
+void QAbstractButton_mouseReleaseEvent(QAbstractButton* self, QMouseEvent* e);
+void QAbstractButton_mouseMoveEvent(QAbstractButton* self, QMouseEvent* e);
+void QAbstractButton_focusInEvent(QAbstractButton* self, QFocusEvent* e);
+void QAbstractButton_focusOutEvent(QAbstractButton* self, QFocusEvent* e);
+void QAbstractButton_changeEvent(QAbstractButton* self, QEvent* e);
+void QAbstractButton_timerEvent(QAbstractButton* self, QTimerEvent* e);
+struct miqt_string QAbstractButton_tr2(const char* s, const char* c);
+struct miqt_string QAbstractButton_tr3(const char* s, const char* c, int n);
+void QAbstractButton_clickedWithChecked(QAbstractButton* self, bool checked);
+void QAbstractButton_connect_clickedWithChecked(QAbstractButton* self, intptr_t slot);
+
+bool QAbstractButton_override_virtual_paintEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_paintEvent(void* self, QPaintEvent* e);
+bool QAbstractButton_override_virtual_hitButton(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_hitButton(const void* self, QPoint* pos);
+bool QAbstractButton_override_virtual_checkStateSet(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_checkStateSet(void* self);
+bool QAbstractButton_override_virtual_nextCheckState(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_nextCheckState(void* self);
+bool QAbstractButton_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_event(void* self, QEvent* e);
+bool QAbstractButton_override_virtual_keyPressEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_keyPressEvent(void* self, QKeyEvent* e);
+bool QAbstractButton_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_keyReleaseEvent(void* self, QKeyEvent* e);
+bool QAbstractButton_override_virtual_mousePressEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_mousePressEvent(void* self, QMouseEvent* e);
+bool QAbstractButton_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* e);
+bool QAbstractButton_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_mouseMoveEvent(void* self, QMouseEvent* e);
+bool QAbstractButton_override_virtual_focusInEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_focusInEvent(void* self, QFocusEvent* e);
+bool QAbstractButton_override_virtual_focusOutEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_focusOutEvent(void* self, QFocusEvent* e);
+bool QAbstractButton_override_virtual_changeEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_changeEvent(void* self, QEvent* e);
+bool QAbstractButton_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_timerEvent(void* self, QTimerEvent* e);
+bool QAbstractButton_override_virtual_devType(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_devType(const void* self);
+bool QAbstractButton_override_virtual_setVisible(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_setVisible(void* self, bool visible);
+bool QAbstractButton_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractButton_virtualbase_sizeHint(const void* self);
+bool QAbstractButton_override_virtual_minimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractButton_virtualbase_minimumSizeHint(const void* self);
+bool QAbstractButton_override_virtual_heightForWidth(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_heightForWidth(const void* self, int param1);
+bool QAbstractButton_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_hasHeightForWidth(const void* self);
+bool QAbstractButton_override_virtual_paintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractButton_virtualbase_paintEngine(const void* self);
+bool QAbstractButton_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
+bool QAbstractButton_override_virtual_wheelEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_wheelEvent(void* self, QWheelEvent* event);
+bool QAbstractButton_override_virtual_enterEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_enterEvent(void* self, QEnterEvent* event);
+bool QAbstractButton_override_virtual_leaveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_leaveEvent(void* self, QEvent* event);
+bool QAbstractButton_override_virtual_moveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_moveEvent(void* self, QMoveEvent* event);
+bool QAbstractButton_override_virtual_resizeEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_resizeEvent(void* self, QResizeEvent* event);
+bool QAbstractButton_override_virtual_closeEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_closeEvent(void* self, QCloseEvent* event);
+bool QAbstractButton_override_virtual_contextMenuEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
+bool QAbstractButton_override_virtual_tabletEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_tabletEvent(void* self, QTabletEvent* event);
+bool QAbstractButton_override_virtual_actionEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_actionEvent(void* self, QActionEvent* event);
+bool QAbstractButton_override_virtual_dragEnterEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
+bool QAbstractButton_override_virtual_dragMoveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
+bool QAbstractButton_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
+bool QAbstractButton_override_virtual_dropEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_dropEvent(void* self, QDropEvent* event);
+bool QAbstractButton_override_virtual_showEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_showEvent(void* self, QShowEvent* event);
+bool QAbstractButton_override_virtual_hideEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_hideEvent(void* self, QHideEvent* event);
+bool QAbstractButton_override_virtual_nativeEvent(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+bool QAbstractButton_override_virtual_metric(void* self, intptr_t slot);
+int QAbstractButton_virtualbase_metric(const void* self, int param1);
+bool QAbstractButton_override_virtual_initPainter(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_initPainter(const void* self, QPainter* painter);
+bool QAbstractButton_override_virtual_redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractButton_virtualbase_redirected(const void* self, QPoint* offset);
+bool QAbstractButton_override_virtual_sharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractButton_virtualbase_sharedPainter(const void* self);
+bool QAbstractButton_override_virtual_inputMethodEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1);
+bool QAbstractButton_override_virtual_inputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractButton_virtualbase_inputMethodQuery(const void* self, int param1);
+bool QAbstractButton_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_focusNextPrevChild(void* self, bool next);
+bool QAbstractButton_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractButton_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractButton_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractButton_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractButton_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractButton_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractButton_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QAbstractButton_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
+void QAbstractButton_protectedbase_create(bool* _dynamic_cast_ok, void* self);
+void QAbstractButton_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
+bool QAbstractButton_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
+bool QAbstractButton_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
+QObject* QAbstractButton_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractButton_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractButton_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractButton_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractButton_delete(QAbstractButton* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstracteventdispatcher.cpp

@@ -0,0 +1,210 @@
+#include <QAbstractEventDispatcher>
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo
+#include <QAbstractNativeEventFilter>
+#include <QByteArray>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QSocketNotifier>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QThread>
+#include <qabstracteventdispatcher.h>
+#include "gen_qabstracteventdispatcher.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QAbstractEventDispatcher_aboutToBlock(intptr_t);
+void miqt_exec_callback_QAbstractEventDispatcher_awake(intptr_t);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+void QAbstractEventDispatcher_virtbase(QAbstractEventDispatcher* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAbstractEventDispatcher_metaObject(const QAbstractEventDispatcher* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAbstractEventDispatcher_metacast(QAbstractEventDispatcher* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAbstractEventDispatcher_tr(const char* s) {
+	QString _ret = QAbstractEventDispatcher::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAbstractEventDispatcher* QAbstractEventDispatcher_instance() {
+	return QAbstractEventDispatcher::instance();
+}
+
+bool QAbstractEventDispatcher_processEvents(QAbstractEventDispatcher* self, int flags) {
+	return self->processEvents(static_cast<QEventLoop::ProcessEventsFlags>(flags));
+}
+
+void QAbstractEventDispatcher_registerSocketNotifier(QAbstractEventDispatcher* self, QSocketNotifier* notifier) {
+	self->registerSocketNotifier(notifier);
+}
+
+void QAbstractEventDispatcher_unregisterSocketNotifier(QAbstractEventDispatcher* self, QSocketNotifier* notifier) {
+	self->unregisterSocketNotifier(notifier);
+}
+
+int QAbstractEventDispatcher_registerTimer(QAbstractEventDispatcher* self, long long interval, int timerType, QObject* object) {
+	return self->registerTimer(static_cast<qint64>(interval), static_cast<Qt::TimerType>(timerType), object);
+}
+
+void QAbstractEventDispatcher_registerTimer2(QAbstractEventDispatcher* self, int timerId, long long interval, int timerType, QObject* object) {
+	self->registerTimer(static_cast<int>(timerId), static_cast<qint64>(interval), static_cast<Qt::TimerType>(timerType), object);
+}
+
+bool QAbstractEventDispatcher_unregisterTimer(QAbstractEventDispatcher* self, int timerId) {
+	return self->unregisterTimer(static_cast<int>(timerId));
+}
+
+bool QAbstractEventDispatcher_unregisterTimers(QAbstractEventDispatcher* self, QObject* object) {
+	return self->unregisterTimers(object);
+}
+
+struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */  QAbstractEventDispatcher_registeredTimers(const QAbstractEventDispatcher* self, QObject* object) {
+	QList<QAbstractEventDispatcher::TimerInfo> _ret = self->registeredTimers(object);
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QAbstractEventDispatcher__TimerInfo** _arr = static_cast<QAbstractEventDispatcher__TimerInfo**>(malloc(sizeof(QAbstractEventDispatcher__TimerInfo*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = new QAbstractEventDispatcher::TimerInfo(_ret[i]);
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+int QAbstractEventDispatcher_remainingTime(QAbstractEventDispatcher* self, int timerId) {
+	return self->remainingTime(static_cast<int>(timerId));
+}
+
+void QAbstractEventDispatcher_wakeUp(QAbstractEventDispatcher* self) {
+	self->wakeUp();
+}
+
+void QAbstractEventDispatcher_interrupt(QAbstractEventDispatcher* self) {
+	self->interrupt();
+}
+
+void QAbstractEventDispatcher_startingUp(QAbstractEventDispatcher* self) {
+	self->startingUp();
+}
+
+void QAbstractEventDispatcher_closingDown(QAbstractEventDispatcher* self) {
+	self->closingDown();
+}
+
+void QAbstractEventDispatcher_installNativeEventFilter(QAbstractEventDispatcher* self, QAbstractNativeEventFilter* filterObj) {
+	self->installNativeEventFilter(filterObj);
+}
+
+void QAbstractEventDispatcher_removeNativeEventFilter(QAbstractEventDispatcher* self, QAbstractNativeEventFilter* filterObj) {
+	self->removeNativeEventFilter(filterObj);
+}
+
+bool QAbstractEventDispatcher_filterNativeEvent(QAbstractEventDispatcher* self, struct miqt_string eventType, void* message, intptr_t* result) {
+	QByteArray eventType_QByteArray(eventType.data, eventType.len);
+	return self->filterNativeEvent(eventType_QByteArray, message, (qintptr*)(result));
+}
+
+void QAbstractEventDispatcher_aboutToBlock(QAbstractEventDispatcher* self) {
+	self->aboutToBlock();
+}
+
+void QAbstractEventDispatcher_connect_aboutToBlock(QAbstractEventDispatcher* self, intptr_t slot) {
+	QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), self, [=]() {
+		miqt_exec_callback_QAbstractEventDispatcher_aboutToBlock(slot);
+	});
+}
+
+void QAbstractEventDispatcher_awake(QAbstractEventDispatcher* self) {
+	self->awake();
+}
+
+void QAbstractEventDispatcher_connect_awake(QAbstractEventDispatcher* self, intptr_t slot) {
+	QAbstractEventDispatcher::connect(self, static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), self, [=]() {
+		miqt_exec_callback_QAbstractEventDispatcher_awake(slot);
+	});
+}
+
+struct miqt_string QAbstractEventDispatcher_tr2(const char* s, const char* c) {
+	QString _ret = QAbstractEventDispatcher::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAbstractEventDispatcher_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAbstractEventDispatcher::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAbstractEventDispatcher* QAbstractEventDispatcher_instanceWithThread(QThread* thread) {
+	return QAbstractEventDispatcher::instance(thread);
+}
+
+void QAbstractEventDispatcher_delete(QAbstractEventDispatcher* self) {
+	delete self;
+}
+
+QAbstractEventDispatcher__TimerInfo* QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t) {
+	return new (std::nothrow) QAbstractEventDispatcher::TimerInfo(static_cast<int>(id), static_cast<int>(i), static_cast<Qt::TimerType>(t));
+}
+
+int QAbstractEventDispatcher__TimerInfo_timerId(const QAbstractEventDispatcher__TimerInfo* self) {
+	return self->timerId;
+}
+
+void QAbstractEventDispatcher__TimerInfo_setTimerId(QAbstractEventDispatcher__TimerInfo* self, int timerId) {
+	self->timerId = static_cast<int>(timerId);
+}
+
+int QAbstractEventDispatcher__TimerInfo_interval(const QAbstractEventDispatcher__TimerInfo* self) {
+	return self->interval;
+}
+
+void QAbstractEventDispatcher__TimerInfo_setInterval(QAbstractEventDispatcher__TimerInfo* self, int interval) {
+	self->interval = static_cast<int>(interval);
+}
+
+int QAbstractEventDispatcher__TimerInfo_timerType(const QAbstractEventDispatcher__TimerInfo* self) {
+	Qt::TimerType timerType_ret = self->timerType;
+	return static_cast<int>(timerType_ret);
+}
+
+void QAbstractEventDispatcher__TimerInfo_setTimerType(QAbstractEventDispatcher__TimerInfo* self, int timerType) {
+	self->timerType = static_cast<Qt::TimerType>(timerType);
+}
+
+void QAbstractEventDispatcher__TimerInfo_delete(QAbstractEventDispatcher__TimerInfo* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qabstracteventdispatcher.go

@@ -0,0 +1,303 @@
+package qt6
+
+/*
+
+#include "gen_qabstracteventdispatcher.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAbstractEventDispatcher struct {
+	h *C.QAbstractEventDispatcher
+	*QObject
+}
+
+func (this *QAbstractEventDispatcher) cPointer() *C.QAbstractEventDispatcher {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAbstractEventDispatcher) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAbstractEventDispatcher constructs the type using only CGO pointers.
+func newQAbstractEventDispatcher(h *C.QAbstractEventDispatcher) *QAbstractEventDispatcher {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QAbstractEventDispatcher_virtbase(h, &outptr_QObject)
+
+	return &QAbstractEventDispatcher{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQAbstractEventDispatcher constructs the type using only unsafe pointers.
+func UnsafeNewQAbstractEventDispatcher(h unsafe.Pointer) *QAbstractEventDispatcher {
+	return newQAbstractEventDispatcher((*C.QAbstractEventDispatcher)(h))
+}
+
+func (this *QAbstractEventDispatcher) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAbstractEventDispatcher_metaObject(this.h))
+}
+
+func (this *QAbstractEventDispatcher) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAbstractEventDispatcher_metacast(this.h, param1_Cstring))
+}
+
+func QAbstractEventDispatcher_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractEventDispatcher_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAbstractEventDispatcher_Instance() *QAbstractEventDispatcher {
+	return newQAbstractEventDispatcher(C.QAbstractEventDispatcher_instance())
+}
+
+func (this *QAbstractEventDispatcher) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
+	return (bool)(C.QAbstractEventDispatcher_processEvents(this.h, (C.int)(flags)))
+}
+
+func (this *QAbstractEventDispatcher) RegisterSocketNotifier(notifier *QSocketNotifier) {
+	C.QAbstractEventDispatcher_registerSocketNotifier(this.h, notifier.cPointer())
+}
+
+func (this *QAbstractEventDispatcher) UnregisterSocketNotifier(notifier *QSocketNotifier) {
+	C.QAbstractEventDispatcher_unregisterSocketNotifier(this.h, notifier.cPointer())
+}
+
+func (this *QAbstractEventDispatcher) RegisterTimer(interval int64, timerType TimerType, object *QObject) int {
+	return (int)(C.QAbstractEventDispatcher_registerTimer(this.h, (C.longlong)(interval), (C.int)(timerType), object.cPointer()))
+}
+
+func (this *QAbstractEventDispatcher) RegisterTimer2(timerId int, interval int64, timerType TimerType, object *QObject) {
+	C.QAbstractEventDispatcher_registerTimer2(this.h, (C.int)(timerId), (C.longlong)(interval), (C.int)(timerType), object.cPointer())
+}
+
+func (this *QAbstractEventDispatcher) UnregisterTimer(timerId int) bool {
+	return (bool)(C.QAbstractEventDispatcher_unregisterTimer(this.h, (C.int)(timerId)))
+}
+
+func (this *QAbstractEventDispatcher) UnregisterTimers(object *QObject) bool {
+	return (bool)(C.QAbstractEventDispatcher_unregisterTimers(this.h, object.cPointer()))
+}
+
+func (this *QAbstractEventDispatcher) RegisteredTimers(object *QObject) []QAbstractEventDispatcher__TimerInfo {
+	var _ma C.struct_miqt_array = C.QAbstractEventDispatcher_registeredTimers(this.h, object.cPointer())
+	_ret := make([]QAbstractEventDispatcher__TimerInfo, int(_ma.len))
+	_outCast := (*[0xffff]*C.QAbstractEventDispatcher__TimerInfo)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_lv_goptr := newQAbstractEventDispatcher__TimerInfo(_outCast[i])
+		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+		_ret[i] = *_lv_goptr
+	}
+	return _ret
+}
+
+func (this *QAbstractEventDispatcher) RemainingTime(timerId int) int {
+	return (int)(C.QAbstractEventDispatcher_remainingTime(this.h, (C.int)(timerId)))
+}
+
+func (this *QAbstractEventDispatcher) WakeUp() {
+	C.QAbstractEventDispatcher_wakeUp(this.h)
+}
+
+func (this *QAbstractEventDispatcher) Interrupt() {
+	C.QAbstractEventDispatcher_interrupt(this.h)
+}
+
+func (this *QAbstractEventDispatcher) StartingUp() {
+	C.QAbstractEventDispatcher_startingUp(this.h)
+}
+
+func (this *QAbstractEventDispatcher) ClosingDown() {
+	C.QAbstractEventDispatcher_closingDown(this.h)
+}
+
+func (this *QAbstractEventDispatcher) InstallNativeEventFilter(filterObj *QAbstractNativeEventFilter) {
+	C.QAbstractEventDispatcher_installNativeEventFilter(this.h, filterObj.cPointer())
+}
+
+func (this *QAbstractEventDispatcher) RemoveNativeEventFilter(filterObj *QAbstractNativeEventFilter) {
+	C.QAbstractEventDispatcher_removeNativeEventFilter(this.h, filterObj.cPointer())
+}
+
+func (this *QAbstractEventDispatcher) FilterNativeEvent(eventType []byte, message unsafe.Pointer, result *uintptr) bool {
+	eventType_alias := C.struct_miqt_string{}
+	if len(eventType) > 0 {
+		eventType_alias.data = (*C.char)(unsafe.Pointer(&eventType[0]))
+	} else {
+		eventType_alias.data = (*C.char)(unsafe.Pointer(nil))
+	}
+	eventType_alias.len = C.size_t(len(eventType))
+	return (bool)(C.QAbstractEventDispatcher_filterNativeEvent(this.h, eventType_alias, message, (*C.intptr_t)(unsafe.Pointer(result))))
+}
+
+func (this *QAbstractEventDispatcher) AboutToBlock() {
+	C.QAbstractEventDispatcher_aboutToBlock(this.h)
+}
+func (this *QAbstractEventDispatcher) OnAboutToBlock(slot func()) {
+	C.QAbstractEventDispatcher_connect_aboutToBlock(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_aboutToBlock
+func miqt_exec_callback_QAbstractEventDispatcher_aboutToBlock(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func (this *QAbstractEventDispatcher) Awake() {
+	C.QAbstractEventDispatcher_awake(this.h)
+}
+func (this *QAbstractEventDispatcher) OnAwake(slot func()) {
+	C.QAbstractEventDispatcher_connect_awake(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractEventDispatcher_awake
+func miqt_exec_callback_QAbstractEventDispatcher_awake(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func QAbstractEventDispatcher_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractEventDispatcher_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAbstractEventDispatcher_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractEventDispatcher_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAbstractEventDispatcher_InstanceWithThread(thread *QThread) *QAbstractEventDispatcher {
+	return newQAbstractEventDispatcher(C.QAbstractEventDispatcher_instanceWithThread(thread.cPointer()))
+}
+
+// Delete this object from C++ memory.
+func (this *QAbstractEventDispatcher) Delete() {
+	C.QAbstractEventDispatcher_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAbstractEventDispatcher) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAbstractEventDispatcher) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QAbstractEventDispatcher__TimerInfo struct {
+	h *C.QAbstractEventDispatcher__TimerInfo
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) cPointer() *C.QAbstractEventDispatcher__TimerInfo {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAbstractEventDispatcher__TimerInfo constructs the type using only CGO pointers.
+func newQAbstractEventDispatcher__TimerInfo(h *C.QAbstractEventDispatcher__TimerInfo) *QAbstractEventDispatcher__TimerInfo {
+	if h == nil {
+		return nil
+	}
+
+	return &QAbstractEventDispatcher__TimerInfo{h: h}
+}
+
+// UnsafeNewQAbstractEventDispatcher__TimerInfo constructs the type using only unsafe pointers.
+func UnsafeNewQAbstractEventDispatcher__TimerInfo(h unsafe.Pointer) *QAbstractEventDispatcher__TimerInfo {
+	return newQAbstractEventDispatcher__TimerInfo((*C.QAbstractEventDispatcher__TimerInfo)(h))
+}
+
+// NewQAbstractEventDispatcher__TimerInfo constructs a new QAbstractEventDispatcher::TimerInfo object.
+func NewQAbstractEventDispatcher__TimerInfo(id int, i int, t TimerType) *QAbstractEventDispatcher__TimerInfo {
+
+	return newQAbstractEventDispatcher__TimerInfo(C.QAbstractEventDispatcher__TimerInfo_new((C.int)(id), (C.int)(i), (C.int)(t)))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) TimerId() int {
+	return (int)(C.QAbstractEventDispatcher__TimerInfo_timerId(this.h))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) SetTimerId(timerId int) {
+	C.QAbstractEventDispatcher__TimerInfo_setTimerId(this.h, (C.int)(timerId))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) Interval() int {
+	return (int)(C.QAbstractEventDispatcher__TimerInfo_interval(this.h))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) SetInterval(interval int) {
+	C.QAbstractEventDispatcher__TimerInfo_setInterval(this.h, (C.int)(interval))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) TimerType() TimerType {
+	return (TimerType)(C.QAbstractEventDispatcher__TimerInfo_timerType(this.h))
+}
+
+func (this *QAbstractEventDispatcher__TimerInfo) SetTimerType(timerType TimerType) {
+	C.QAbstractEventDispatcher__TimerInfo_setTimerType(this.h, (C.int)(timerType))
+}
+
+// Delete this object from C++ memory.
+func (this *QAbstractEventDispatcher__TimerInfo) Delete() {
+	C.QAbstractEventDispatcher__TimerInfo_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAbstractEventDispatcher__TimerInfo) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAbstractEventDispatcher__TimerInfo) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qabstracteventdispatcher.h

@@ -0,0 +1,86 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTEVENTDISPATCHER_H
+#define MIQT_QT6_GEN_QABSTRACTEVENTDISPATCHER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractEventDispatcher;
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAbstractEventDispatcher__TimerInfo)
+typedef QAbstractEventDispatcher::TimerInfo QAbstractEventDispatcher__TimerInfo;
+#else
+class QAbstractEventDispatcher__TimerInfo;
+#endif
+class QAbstractNativeEventFilter;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QSocketNotifier;
+class QThread;
+#else
+typedef struct QAbstractEventDispatcher QAbstractEventDispatcher;
+typedef struct QAbstractEventDispatcher__TimerInfo QAbstractEventDispatcher__TimerInfo;
+typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QSocketNotifier QSocketNotifier;
+typedef struct QThread QThread;
+#endif
+
+void QAbstractEventDispatcher_virtbase(QAbstractEventDispatcher* src, QObject** outptr_QObject);
+QMetaObject* QAbstractEventDispatcher_metaObject(const QAbstractEventDispatcher* self);
+void* QAbstractEventDispatcher_metacast(QAbstractEventDispatcher* self, const char* param1);
+struct miqt_string QAbstractEventDispatcher_tr(const char* s);
+QAbstractEventDispatcher* QAbstractEventDispatcher_instance();
+bool QAbstractEventDispatcher_processEvents(QAbstractEventDispatcher* self, int flags);
+void QAbstractEventDispatcher_registerSocketNotifier(QAbstractEventDispatcher* self, QSocketNotifier* notifier);
+void QAbstractEventDispatcher_unregisterSocketNotifier(QAbstractEventDispatcher* self, QSocketNotifier* notifier);
+int QAbstractEventDispatcher_registerTimer(QAbstractEventDispatcher* self, long long interval, int timerType, QObject* object);
+void QAbstractEventDispatcher_registerTimer2(QAbstractEventDispatcher* self, int timerId, long long interval, int timerType, QObject* object);
+bool QAbstractEventDispatcher_unregisterTimer(QAbstractEventDispatcher* self, int timerId);
+bool QAbstractEventDispatcher_unregisterTimers(QAbstractEventDispatcher* self, QObject* object);
+struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */  QAbstractEventDispatcher_registeredTimers(const QAbstractEventDispatcher* self, QObject* object);
+int QAbstractEventDispatcher_remainingTime(QAbstractEventDispatcher* self, int timerId);
+void QAbstractEventDispatcher_wakeUp(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_interrupt(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_startingUp(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_closingDown(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_installNativeEventFilter(QAbstractEventDispatcher* self, QAbstractNativeEventFilter* filterObj);
+void QAbstractEventDispatcher_removeNativeEventFilter(QAbstractEventDispatcher* self, QAbstractNativeEventFilter* filterObj);
+bool QAbstractEventDispatcher_filterNativeEvent(QAbstractEventDispatcher* self, struct miqt_string eventType, void* message, intptr_t* result);
+void QAbstractEventDispatcher_aboutToBlock(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_connect_aboutToBlock(QAbstractEventDispatcher* self, intptr_t slot);
+void QAbstractEventDispatcher_awake(QAbstractEventDispatcher* self);
+void QAbstractEventDispatcher_connect_awake(QAbstractEventDispatcher* self, intptr_t slot);
+struct miqt_string QAbstractEventDispatcher_tr2(const char* s, const char* c);
+struct miqt_string QAbstractEventDispatcher_tr3(const char* s, const char* c, int n);
+QAbstractEventDispatcher* QAbstractEventDispatcher_instanceWithThread(QThread* thread);
+
+void QAbstractEventDispatcher_delete(QAbstractEventDispatcher* self);
+
+QAbstractEventDispatcher__TimerInfo* QAbstractEventDispatcher__TimerInfo_new(int id, int i, int t);
+int QAbstractEventDispatcher__TimerInfo_timerId(const QAbstractEventDispatcher__TimerInfo* self);
+void QAbstractEventDispatcher__TimerInfo_setTimerId(QAbstractEventDispatcher__TimerInfo* self, int timerId);
+int QAbstractEventDispatcher__TimerInfo_interval(const QAbstractEventDispatcher__TimerInfo* self);
+void QAbstractEventDispatcher__TimerInfo_setInterval(QAbstractEventDispatcher__TimerInfo* self, int interval);
+int QAbstractEventDispatcher__TimerInfo_timerType(const QAbstractEventDispatcher__TimerInfo* self);
+void QAbstractEventDispatcher__TimerInfo_setTimerType(QAbstractEventDispatcher__TimerInfo* self, int timerType);
+
+void QAbstractEventDispatcher__TimerInfo_delete(QAbstractEventDispatcher__TimerInfo* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractfileiconprovider.cpp

@@ -0,0 +1,232 @@
+#include <QAbstractFileIconProvider>
+#include <QFileInfo>
+#include <QIcon>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qabstractfileiconprovider.h>
+#include "gen_qabstractfileiconprovider.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+QIcon* miqt_exec_callback_QAbstractFileIconProvider_icon(const QAbstractFileIconProvider*, intptr_t, int);
+QIcon* miqt_exec_callback_QAbstractFileIconProvider_iconWithQFileInfo(const QAbstractFileIconProvider*, intptr_t, QFileInfo*);
+struct miqt_string miqt_exec_callback_QAbstractFileIconProvider_type(const QAbstractFileIconProvider*, intptr_t, QFileInfo*);
+void miqt_exec_callback_QAbstractFileIconProvider_setOptions(QAbstractFileIconProvider*, intptr_t, int);
+int miqt_exec_callback_QAbstractFileIconProvider_options(const QAbstractFileIconProvider*, intptr_t);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAbstractFileIconProvider final : public QAbstractFileIconProvider {
+public:
+
+	MiqtVirtualQAbstractFileIconProvider(): QAbstractFileIconProvider() {}
+
+	virtual ~MiqtVirtualQAbstractFileIconProvider() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__icon = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QIcon icon(QAbstractFileIconProvider::IconType param1) const override {
+		if (handle__icon == 0) {
+			return QAbstractFileIconProvider::icon(param1);
+		}
+
+		QAbstractFileIconProvider::IconType param1_ret = param1;
+		int sigval1 = static_cast<int>(param1_ret);
+		QIcon* callback_return_value = miqt_exec_callback_QAbstractFileIconProvider_icon(this, handle__icon, sigval1);
+		return *callback_return_value;
+	}
+
+	friend QIcon* QAbstractFileIconProvider_virtualbase_icon(const void* self, int param1);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__iconWithQFileInfo = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QIcon icon(const QFileInfo& param1) const override {
+		if (handle__iconWithQFileInfo == 0) {
+			return QAbstractFileIconProvider::icon(param1);
+		}
+
+		const QFileInfo& param1_ret = param1;
+		// Cast returned reference into pointer
+		QFileInfo* sigval1 = const_cast<QFileInfo*>(&param1_ret);
+		QIcon* callback_return_value = miqt_exec_callback_QAbstractFileIconProvider_iconWithQFileInfo(this, handle__iconWithQFileInfo, sigval1);
+		return *callback_return_value;
+	}
+
+	friend QIcon* QAbstractFileIconProvider_virtualbase_iconWithQFileInfo(const void* self, QFileInfo* param1);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__type = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QString type(const QFileInfo& param1) const override {
+		if (handle__type == 0) {
+			return QAbstractFileIconProvider::type(param1);
+		}
+
+		const QFileInfo& param1_ret = param1;
+		// Cast returned reference into pointer
+		QFileInfo* sigval1 = const_cast<QFileInfo*>(&param1_ret);
+		struct miqt_string callback_return_value = miqt_exec_callback_QAbstractFileIconProvider_type(this, handle__type, sigval1);
+		QString callback_return_value_QString = QString::fromUtf8(callback_return_value.data, callback_return_value.len);
+		return callback_return_value_QString;
+	}
+
+	friend struct miqt_string QAbstractFileIconProvider_virtualbase_type(const void* self, QFileInfo* param1);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__setOptions = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void setOptions(QAbstractFileIconProvider::Options options) override {
+		if (handle__setOptions == 0) {
+			QAbstractFileIconProvider::setOptions(options);
+			return;
+		}
+
+		QAbstractFileIconProvider::Options options_ret = options;
+		int sigval1 = static_cast<int>(options_ret);
+		miqt_exec_callback_QAbstractFileIconProvider_setOptions(this, handle__setOptions, sigval1);
+
+	}
+
+	friend void QAbstractFileIconProvider_virtualbase_setOptions(void* self, int options);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__options = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QAbstractFileIconProvider::Options options() const override {
+		if (handle__options == 0) {
+			return QAbstractFileIconProvider::options();
+		}
+
+		int callback_return_value = miqt_exec_callback_QAbstractFileIconProvider_options(this, handle__options);
+		return static_cast<QAbstractFileIconProvider::Options>(callback_return_value);
+	}
+
+	friend int QAbstractFileIconProvider_virtualbase_options(const void* self);
+
+};
+
+QAbstractFileIconProvider* QAbstractFileIconProvider_new() {
+	return new (std::nothrow) MiqtVirtualQAbstractFileIconProvider();
+}
+
+QIcon* QAbstractFileIconProvider_icon(const QAbstractFileIconProvider* self, int param1) {
+	return new QIcon(self->icon(static_cast<QAbstractFileIconProvider::IconType>(param1)));
+}
+
+QIcon* QAbstractFileIconProvider_iconWithQFileInfo(const QAbstractFileIconProvider* self, QFileInfo* param1) {
+	return new QIcon(self->icon(*param1));
+}
+
+struct miqt_string QAbstractFileIconProvider_type(const QAbstractFileIconProvider* self, QFileInfo* param1) {
+	QString _ret = self->type(*param1);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAbstractFileIconProvider_setOptions(QAbstractFileIconProvider* self, int options) {
+	self->setOptions(static_cast<QAbstractFileIconProvider::Options>(options));
+}
+
+int QAbstractFileIconProvider_options(const QAbstractFileIconProvider* self) {
+	QAbstractFileIconProvider::Options _ret = self->options();
+	return static_cast<int>(_ret);
+}
+
+bool QAbstractFileIconProvider_override_virtual_icon(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractFileIconProvider* self_cast = dynamic_cast<MiqtVirtualQAbstractFileIconProvider*>( (QAbstractFileIconProvider*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__icon = slot;
+	return true;
+}
+
+QIcon* QAbstractFileIconProvider_virtualbase_icon(const void* self, int param1) {
+	return new QIcon(static_cast<const MiqtVirtualQAbstractFileIconProvider*>(self)->QAbstractFileIconProvider::icon(static_cast<MiqtVirtualQAbstractFileIconProvider::IconType>(param1)));
+}
+
+bool QAbstractFileIconProvider_override_virtual_iconWithQFileInfo(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractFileIconProvider* self_cast = dynamic_cast<MiqtVirtualQAbstractFileIconProvider*>( (QAbstractFileIconProvider*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__iconWithQFileInfo = slot;
+	return true;
+}
+
+QIcon* QAbstractFileIconProvider_virtualbase_iconWithQFileInfo(const void* self, QFileInfo* param1) {
+	return new QIcon(static_cast<const MiqtVirtualQAbstractFileIconProvider*>(self)->QAbstractFileIconProvider::icon(*param1));
+}
+
+bool QAbstractFileIconProvider_override_virtual_type(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractFileIconProvider* self_cast = dynamic_cast<MiqtVirtualQAbstractFileIconProvider*>( (QAbstractFileIconProvider*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__type = slot;
+	return true;
+}
+
+struct miqt_string QAbstractFileIconProvider_virtualbase_type(const void* self, QFileInfo* param1) {
+	QString _ret = static_cast<const MiqtVirtualQAbstractFileIconProvider*>(self)->QAbstractFileIconProvider::type(*param1);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QAbstractFileIconProvider_override_virtual_setOptions(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractFileIconProvider* self_cast = dynamic_cast<MiqtVirtualQAbstractFileIconProvider*>( (QAbstractFileIconProvider*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__setOptions = slot;
+	return true;
+}
+
+void QAbstractFileIconProvider_virtualbase_setOptions(void* self, int options) {
+	static_cast<MiqtVirtualQAbstractFileIconProvider*>(self)->QAbstractFileIconProvider::setOptions(static_cast<MiqtVirtualQAbstractFileIconProvider::Options>(options));
+}
+
+bool QAbstractFileIconProvider_override_virtual_options(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractFileIconProvider* self_cast = dynamic_cast<MiqtVirtualQAbstractFileIconProvider*>( (QAbstractFileIconProvider*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__options = slot;
+	return true;
+}
+
+int QAbstractFileIconProvider_virtualbase_options(const void* self) {
+	MiqtVirtualQAbstractFileIconProvider::Options _ret = static_cast<const MiqtVirtualQAbstractFileIconProvider*>(self)->QAbstractFileIconProvider::options();
+	return static_cast<int>(_ret);
+}
+
+void QAbstractFileIconProvider_delete(QAbstractFileIconProvider* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qabstractfileiconprovider.go

@@ -0,0 +1,257 @@
+package qt6
+
+/*
+
+#include "gen_qabstractfileiconprovider.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAbstractFileIconProvider__IconType int
+
+const (
+	QAbstractFileIconProvider__Computer QAbstractFileIconProvider__IconType = 0
+	QAbstractFileIconProvider__Desktop  QAbstractFileIconProvider__IconType = 1
+	QAbstractFileIconProvider__Trashcan QAbstractFileIconProvider__IconType = 2
+	QAbstractFileIconProvider__Network  QAbstractFileIconProvider__IconType = 3
+	QAbstractFileIconProvider__Drive    QAbstractFileIconProvider__IconType = 4
+	QAbstractFileIconProvider__Folder   QAbstractFileIconProvider__IconType = 5
+	QAbstractFileIconProvider__File     QAbstractFileIconProvider__IconType = 6
+)
+
+type QAbstractFileIconProvider__Option int
+
+const (
+	QAbstractFileIconProvider__DontUseCustomDirectoryIcons QAbstractFileIconProvider__Option = 1
+)
+
+type QAbstractFileIconProvider struct {
+	h *C.QAbstractFileIconProvider
+}
+
+func (this *QAbstractFileIconProvider) cPointer() *C.QAbstractFileIconProvider {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAbstractFileIconProvider) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAbstractFileIconProvider constructs the type using only CGO pointers.
+func newQAbstractFileIconProvider(h *C.QAbstractFileIconProvider) *QAbstractFileIconProvider {
+	if h == nil {
+		return nil
+	}
+
+	return &QAbstractFileIconProvider{h: h}
+}
+
+// UnsafeNewQAbstractFileIconProvider constructs the type using only unsafe pointers.
+func UnsafeNewQAbstractFileIconProvider(h unsafe.Pointer) *QAbstractFileIconProvider {
+	return newQAbstractFileIconProvider((*C.QAbstractFileIconProvider)(h))
+}
+
+// NewQAbstractFileIconProvider constructs a new QAbstractFileIconProvider object.
+func NewQAbstractFileIconProvider() *QAbstractFileIconProvider {
+
+	return newQAbstractFileIconProvider(C.QAbstractFileIconProvider_new())
+}
+
+func (this *QAbstractFileIconProvider) Icon(param1 QAbstractFileIconProvider__IconType) *QIcon {
+	_goptr := newQIcon(C.QAbstractFileIconProvider_icon(this.h, (C.int)(param1)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAbstractFileIconProvider) IconWithQFileInfo(param1 *QFileInfo) *QIcon {
+	_goptr := newQIcon(C.QAbstractFileIconProvider_iconWithQFileInfo(this.h, param1.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAbstractFileIconProvider) Type(param1 *QFileInfo) string {
+	var _ms C.struct_miqt_string = C.QAbstractFileIconProvider_type(this.h, param1.cPointer())
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAbstractFileIconProvider) SetOptions(options QAbstractFileIconProvider__Option) {
+	C.QAbstractFileIconProvider_setOptions(this.h, (C.int)(options))
+}
+
+func (this *QAbstractFileIconProvider) Options() QAbstractFileIconProvider__Option {
+	return (QAbstractFileIconProvider__Option)(C.QAbstractFileIconProvider_options(this.h))
+}
+
+func (this *QAbstractFileIconProvider) callVirtualBase_Icon(param1 QAbstractFileIconProvider__IconType) *QIcon {
+
+	_goptr := newQIcon(C.QAbstractFileIconProvider_virtualbase_icon(unsafe.Pointer(this.h), (C.int)(param1)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QAbstractFileIconProvider) OnIcon(slot func(super func(param1 QAbstractFileIconProvider__IconType) *QIcon, param1 QAbstractFileIconProvider__IconType) *QIcon) {
+	ok := C.QAbstractFileIconProvider_override_virtual_icon(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractFileIconProvider_icon
+func miqt_exec_callback_QAbstractFileIconProvider_icon(self *C.QAbstractFileIconProvider, cb C.intptr_t, param1 C.int) *C.QIcon {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 QAbstractFileIconProvider__IconType) *QIcon, param1 QAbstractFileIconProvider__IconType) *QIcon)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (QAbstractFileIconProvider__IconType)(param1)
+
+	virtualReturn := gofunc((&QAbstractFileIconProvider{h: self}).callVirtualBase_Icon, slotval1)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractFileIconProvider) callVirtualBase_IconWithQFileInfo(param1 *QFileInfo) *QIcon {
+
+	_goptr := newQIcon(C.QAbstractFileIconProvider_virtualbase_iconWithQFileInfo(unsafe.Pointer(this.h), param1.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+
+}
+func (this *QAbstractFileIconProvider) OnIconWithQFileInfo(slot func(super func(param1 *QFileInfo) *QIcon, param1 *QFileInfo) *QIcon) {
+	ok := C.QAbstractFileIconProvider_override_virtual_iconWithQFileInfo(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractFileIconProvider_iconWithQFileInfo
+func miqt_exec_callback_QAbstractFileIconProvider_iconWithQFileInfo(self *C.QAbstractFileIconProvider, cb C.intptr_t, param1 *C.QFileInfo) *C.QIcon {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *QFileInfo) *QIcon, param1 *QFileInfo) *QIcon)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQFileInfo(param1)
+
+	virtualReturn := gofunc((&QAbstractFileIconProvider{h: self}).callVirtualBase_IconWithQFileInfo, slotval1)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractFileIconProvider) callVirtualBase_Type(param1 *QFileInfo) string {
+
+	var _ms C.struct_miqt_string = C.QAbstractFileIconProvider_virtualbase_type(unsafe.Pointer(this.h), param1.cPointer())
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+func (this *QAbstractFileIconProvider) OnType(slot func(super func(param1 *QFileInfo) string, param1 *QFileInfo) string) {
+	ok := C.QAbstractFileIconProvider_override_virtual_type(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractFileIconProvider_type
+func miqt_exec_callback_QAbstractFileIconProvider_type(self *C.QAbstractFileIconProvider, cb C.intptr_t, param1 *C.QFileInfo) C.struct_miqt_string {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *QFileInfo) string, param1 *QFileInfo) string)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQFileInfo(param1)
+
+	virtualReturn := gofunc((&QAbstractFileIconProvider{h: self}).callVirtualBase_Type, 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 *QAbstractFileIconProvider) callVirtualBase_SetOptions(options QAbstractFileIconProvider__Option) {
+
+	C.QAbstractFileIconProvider_virtualbase_setOptions(unsafe.Pointer(this.h), (C.int)(options))
+
+}
+func (this *QAbstractFileIconProvider) OnSetOptions(slot func(super func(options QAbstractFileIconProvider__Option), options QAbstractFileIconProvider__Option)) {
+	ok := C.QAbstractFileIconProvider_override_virtual_setOptions(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractFileIconProvider_setOptions
+func miqt_exec_callback_QAbstractFileIconProvider_setOptions(self *C.QAbstractFileIconProvider, cb C.intptr_t, options C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(options QAbstractFileIconProvider__Option), options QAbstractFileIconProvider__Option))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (QAbstractFileIconProvider__Option)(options)
+
+	gofunc((&QAbstractFileIconProvider{h: self}).callVirtualBase_SetOptions, slotval1)
+
+}
+
+func (this *QAbstractFileIconProvider) callVirtualBase_Options() QAbstractFileIconProvider__Option {
+
+	return (QAbstractFileIconProvider__Option)(C.QAbstractFileIconProvider_virtualbase_options(unsafe.Pointer(this.h)))
+
+}
+func (this *QAbstractFileIconProvider) OnOptions(slot func(super func() QAbstractFileIconProvider__Option) QAbstractFileIconProvider__Option) {
+	ok := C.QAbstractFileIconProvider_override_virtual_options(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractFileIconProvider_options
+func miqt_exec_callback_QAbstractFileIconProvider_options(self *C.QAbstractFileIconProvider, cb C.intptr_t) C.int {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() QAbstractFileIconProvider__Option) QAbstractFileIconProvider__Option)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QAbstractFileIconProvider{h: self}).callVirtualBase_Options)
+
+	return (C.int)(virtualReturn)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAbstractFileIconProvider) Delete() {
+	C.QAbstractFileIconProvider_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAbstractFileIconProvider) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAbstractFileIconProvider) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qabstractfileiconprovider.h

@@ -0,0 +1,51 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTFILEICONPROVIDER_H
+#define MIQT_QT6_GEN_QABSTRACTFILEICONPROVIDER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractFileIconProvider;
+class QFileInfo;
+class QIcon;
+#else
+typedef struct QAbstractFileIconProvider QAbstractFileIconProvider;
+typedef struct QFileInfo QFileInfo;
+typedef struct QIcon QIcon;
+#endif
+
+QAbstractFileIconProvider* QAbstractFileIconProvider_new();
+QIcon* QAbstractFileIconProvider_icon(const QAbstractFileIconProvider* self, int param1);
+QIcon* QAbstractFileIconProvider_iconWithQFileInfo(const QAbstractFileIconProvider* self, QFileInfo* param1);
+struct miqt_string QAbstractFileIconProvider_type(const QAbstractFileIconProvider* self, QFileInfo* param1);
+void QAbstractFileIconProvider_setOptions(QAbstractFileIconProvider* self, int options);
+int QAbstractFileIconProvider_options(const QAbstractFileIconProvider* self);
+
+bool QAbstractFileIconProvider_override_virtual_icon(void* self, intptr_t slot);
+QIcon* QAbstractFileIconProvider_virtualbase_icon(const void* self, int param1);
+bool QAbstractFileIconProvider_override_virtual_iconWithQFileInfo(void* self, intptr_t slot);
+QIcon* QAbstractFileIconProvider_virtualbase_iconWithQFileInfo(const void* self, QFileInfo* param1);
+bool QAbstractFileIconProvider_override_virtual_type(void* self, intptr_t slot);
+struct miqt_string QAbstractFileIconProvider_virtualbase_type(const void* self, QFileInfo* param1);
+bool QAbstractFileIconProvider_override_virtual_setOptions(void* self, intptr_t slot);
+void QAbstractFileIconProvider_virtualbase_setOptions(void* self, int options);
+bool QAbstractFileIconProvider_override_virtual_options(void* self, intptr_t slot);
+int QAbstractFileIconProvider_virtualbase_options(const void* self);
+
+void QAbstractFileIconProvider_delete(QAbstractFileIconProvider* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractitemdelegate.cpp

@@ -0,0 +1,837 @@
+#include <QAbstractItemDelegate>
+#include <QAbstractItemModel>
+#include <QAbstractItemView>
+#include <QChildEvent>
+#include <QEvent>
+#include <QHelpEvent>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QModelIndex>
+#include <QObject>
+#include <QPainter>
+#include <QSize>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QStyleOptionViewItem>
+#include <QTimerEvent>
+#include <QWidget>
+#include <qabstractitemdelegate.h>
+#include "gen_qabstractitemdelegate.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QAbstractItemDelegate_commitData(intptr_t, QWidget*);
+void miqt_exec_callback_QAbstractItemDelegate_closeEditor(intptr_t, QWidget*);
+void miqt_exec_callback_QAbstractItemDelegate_sizeHintChanged(intptr_t, QModelIndex*);
+void miqt_exec_callback_QAbstractItemDelegate_closeEditor2(intptr_t, QWidget*, int);
+void miqt_exec_callback_QAbstractItemDelegate_paint(const QAbstractItemDelegate*, intptr_t, QPainter*, QStyleOptionViewItem*, QModelIndex*);
+QSize* miqt_exec_callback_QAbstractItemDelegate_sizeHint(const QAbstractItemDelegate*, intptr_t, QStyleOptionViewItem*, QModelIndex*);
+QWidget* miqt_exec_callback_QAbstractItemDelegate_createEditor(const QAbstractItemDelegate*, intptr_t, QWidget*, QStyleOptionViewItem*, QModelIndex*);
+void miqt_exec_callback_QAbstractItemDelegate_destroyEditor(const QAbstractItemDelegate*, intptr_t, QWidget*, QModelIndex*);
+void miqt_exec_callback_QAbstractItemDelegate_setEditorData(const QAbstractItemDelegate*, intptr_t, QWidget*, QModelIndex*);
+void miqt_exec_callback_QAbstractItemDelegate_setModelData(const QAbstractItemDelegate*, intptr_t, QWidget*, QAbstractItemModel*, QModelIndex*);
+void miqt_exec_callback_QAbstractItemDelegate_updateEditorGeometry(const QAbstractItemDelegate*, intptr_t, QWidget*, QStyleOptionViewItem*, QModelIndex*);
+bool miqt_exec_callback_QAbstractItemDelegate_editorEvent(QAbstractItemDelegate*, intptr_t, QEvent*, QAbstractItemModel*, QStyleOptionViewItem*, QModelIndex*);
+bool miqt_exec_callback_QAbstractItemDelegate_helpEvent(QAbstractItemDelegate*, intptr_t, QHelpEvent*, QAbstractItemView*, QStyleOptionViewItem*, QModelIndex*);
+struct miqt_array /* of int */  miqt_exec_callback_QAbstractItemDelegate_paintingRoles(const QAbstractItemDelegate*, intptr_t);
+bool miqt_exec_callback_QAbstractItemDelegate_event(QAbstractItemDelegate*, intptr_t, QEvent*);
+bool miqt_exec_callback_QAbstractItemDelegate_eventFilter(QAbstractItemDelegate*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAbstractItemDelegate_timerEvent(QAbstractItemDelegate*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAbstractItemDelegate_childEvent(QAbstractItemDelegate*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAbstractItemDelegate_customEvent(QAbstractItemDelegate*, intptr_t, QEvent*);
+void miqt_exec_callback_QAbstractItemDelegate_connectNotify(QAbstractItemDelegate*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAbstractItemDelegate_disconnectNotify(QAbstractItemDelegate*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAbstractItemDelegate final : public QAbstractItemDelegate {
+public:
+
+	MiqtVirtualQAbstractItemDelegate(): QAbstractItemDelegate() {}
+	MiqtVirtualQAbstractItemDelegate(QObject* parent): QAbstractItemDelegate(parent) {}
+
+	virtual ~MiqtVirtualQAbstractItemDelegate() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__paint = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__paint == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+
+		QPainter* sigval1 = painter;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+		miqt_exec_callback_QAbstractItemDelegate_paint(this, handle__paint, sigval1, sigval2, sigval3);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__sizeHint = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__sizeHint == 0) {
+			return QSize(); // Pure virtual, there is no base we can call
+		}
+
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval1 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+		QSize* callback_return_value = miqt_exec_callback_QAbstractItemDelegate_sizeHint(this, handle__sizeHint, sigval1, sigval2);
+		return *callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__createEditor = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__createEditor == 0) {
+			return QAbstractItemDelegate::createEditor(parent, option, index);
+		}
+
+		QWidget* sigval1 = parent;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+		QWidget* callback_return_value = miqt_exec_callback_QAbstractItemDelegate_createEditor(this, handle__createEditor, sigval1, sigval2, sigval3);
+		return callback_return_value;
+	}
+
+	friend QWidget* QAbstractItemDelegate_virtualbase_createEditor(const void* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__destroyEditor = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void destroyEditor(QWidget* editor, const QModelIndex& index) const override {
+		if (handle__destroyEditor == 0) {
+			QAbstractItemDelegate::destroyEditor(editor, index);
+			return;
+		}
+
+		QWidget* sigval1 = editor;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+		miqt_exec_callback_QAbstractItemDelegate_destroyEditor(this, handle__destroyEditor, sigval1, sigval2);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_destroyEditor(const void* self, QWidget* editor, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__setEditorData = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void setEditorData(QWidget* editor, const QModelIndex& index) const override {
+		if (handle__setEditorData == 0) {
+			QAbstractItemDelegate::setEditorData(editor, index);
+			return;
+		}
+
+		QWidget* sigval1 = editor;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval2 = const_cast<QModelIndex*>(&index_ret);
+		miqt_exec_callback_QAbstractItemDelegate_setEditorData(this, handle__setEditorData, sigval1, sigval2);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_setEditorData(const void* self, QWidget* editor, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__setModelData = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const override {
+		if (handle__setModelData == 0) {
+			QAbstractItemDelegate::setModelData(editor, model, index);
+			return;
+		}
+
+		QWidget* sigval1 = editor;
+		QAbstractItemModel* sigval2 = model;
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+		miqt_exec_callback_QAbstractItemDelegate_setModelData(this, handle__setModelData, sigval1, sigval2, sigval3);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_setModelData(const void* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__updateEditorGeometry = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const override {
+		if (handle__updateEditorGeometry == 0) {
+			QAbstractItemDelegate::updateEditorGeometry(editor, option, index);
+			return;
+		}
+
+		QWidget* sigval1 = editor;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval2 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval3 = const_cast<QModelIndex*>(&index_ret);
+		miqt_exec_callback_QAbstractItemDelegate_updateEditorGeometry(this, handle__updateEditorGeometry, sigval1, sigval2, sigval3);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_updateEditorGeometry(const void* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__editorEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) override {
+		if (handle__editorEvent == 0) {
+			return QAbstractItemDelegate::editorEvent(event, model, option, index);
+		}
+
+		QEvent* sigval1 = event;
+		QAbstractItemModel* sigval2 = model;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval3 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval4 = const_cast<QModelIndex*>(&index_ret);
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_editorEvent(this, handle__editorEvent, sigval1, sigval2, sigval3, sigval4);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractItemDelegate_virtualbase_editorEvent(void* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__helpEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool helpEvent(QHelpEvent* event, QAbstractItemView* view, const QStyleOptionViewItem& option, const QModelIndex& index) override {
+		if (handle__helpEvent == 0) {
+			return QAbstractItemDelegate::helpEvent(event, view, option, index);
+		}
+
+		QHelpEvent* sigval1 = event;
+		QAbstractItemView* sigval2 = view;
+		const QStyleOptionViewItem& option_ret = option;
+		// Cast returned reference into pointer
+		QStyleOptionViewItem* sigval3 = const_cast<QStyleOptionViewItem*>(&option_ret);
+		const QModelIndex& index_ret = index;
+		// Cast returned reference into pointer
+		QModelIndex* sigval4 = const_cast<QModelIndex*>(&index_ret);
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_helpEvent(this, handle__helpEvent, sigval1, sigval2, sigval3, sigval4);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractItemDelegate_virtualbase_helpEvent(void* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__paintingRoles = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QList<int> paintingRoles() const override {
+		if (handle__paintingRoles == 0) {
+			return QAbstractItemDelegate::paintingRoles();
+		}
+
+		struct miqt_array /* of int */  callback_return_value = miqt_exec_callback_QAbstractItemDelegate_paintingRoles(this, handle__paintingRoles);
+		QList<int> callback_return_value_QList;
+		callback_return_value_QList.reserve(callback_return_value.len);
+		int* callback_return_value_arr = static_cast<int*>(callback_return_value.data);
+		for(size_t i = 0; i < callback_return_value.len; ++i) {
+			callback_return_value_QList.push_back(static_cast<int>(callback_return_value_arr[i]));
+		}
+		return callback_return_value_QList;
+	}
+
+	friend struct miqt_array /* of int */  QAbstractItemDelegate_virtualbase_paintingRoles(const void* self);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__event == 0) {
+			return QAbstractItemDelegate::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractItemDelegate_virtualbase_event(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__eventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__eventFilter == 0) {
+			return QAbstractItemDelegate::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAbstractItemDelegate_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractItemDelegate_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__timerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__timerEvent == 0) {
+			QAbstractItemDelegate::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractItemDelegate_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_timerEvent(void* self, QTimerEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__childEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__childEvent == 0) {
+			QAbstractItemDelegate::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractItemDelegate_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_childEvent(void* self, QChildEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__customEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__customEvent == 0) {
+			QAbstractItemDelegate::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractItemDelegate_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_customEvent(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__connectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__connectNotify == 0) {
+			QAbstractItemDelegate::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAbstractItemDelegate_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__disconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__disconnectNotify == 0) {
+			QAbstractItemDelegate::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAbstractItemDelegate_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAbstractItemDelegate_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QAbstractItemDelegate_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAbstractItemDelegate_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAbstractItemDelegate_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAbstractItemDelegate_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAbstractItemDelegate* QAbstractItemDelegate_new() {
+	return new (std::nothrow) MiqtVirtualQAbstractItemDelegate();
+}
+
+QAbstractItemDelegate* QAbstractItemDelegate_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQAbstractItemDelegate(parent);
+}
+
+void QAbstractItemDelegate_virtbase(QAbstractItemDelegate* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAbstractItemDelegate_metaObject(const QAbstractItemDelegate* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAbstractItemDelegate_metacast(QAbstractItemDelegate* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAbstractItemDelegate_tr(const char* s) {
+	QString _ret = QAbstractItemDelegate::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAbstractItemDelegate_paint(const QAbstractItemDelegate* self, QPainter* painter, QStyleOptionViewItem* option, QModelIndex* index) {
+	self->paint(painter, *option, *index);
+}
+
+QSize* QAbstractItemDelegate_sizeHint(const QAbstractItemDelegate* self, QStyleOptionViewItem* option, QModelIndex* index) {
+	return new QSize(self->sizeHint(*option, *index));
+}
+
+QWidget* QAbstractItemDelegate_createEditor(const QAbstractItemDelegate* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index) {
+	return self->createEditor(parent, *option, *index);
+}
+
+void QAbstractItemDelegate_destroyEditor(const QAbstractItemDelegate* self, QWidget* editor, QModelIndex* index) {
+	self->destroyEditor(editor, *index);
+}
+
+void QAbstractItemDelegate_setEditorData(const QAbstractItemDelegate* self, QWidget* editor, QModelIndex* index) {
+	self->setEditorData(editor, *index);
+}
+
+void QAbstractItemDelegate_setModelData(const QAbstractItemDelegate* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index) {
+	self->setModelData(editor, model, *index);
+}
+
+void QAbstractItemDelegate_updateEditorGeometry(const QAbstractItemDelegate* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index) {
+	self->updateEditorGeometry(editor, *option, *index);
+}
+
+bool QAbstractItemDelegate_editorEvent(QAbstractItemDelegate* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index) {
+	return self->editorEvent(event, model, *option, *index);
+}
+
+bool QAbstractItemDelegate_helpEvent(QAbstractItemDelegate* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index) {
+	return self->helpEvent(event, view, *option, *index);
+}
+
+struct miqt_array /* of int */  QAbstractItemDelegate_paintingRoles(const QAbstractItemDelegate* self) {
+	QList<int> _ret = self->paintingRoles();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	int* _arr = static_cast<int*>(malloc(sizeof(int) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QAbstractItemDelegate_commitData(QAbstractItemDelegate* self, QWidget* editor) {
+	self->commitData(editor);
+}
+
+void QAbstractItemDelegate_connect_commitData(QAbstractItemDelegate* self, intptr_t slot) {
+	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*)>(&QAbstractItemDelegate::commitData), self, [=](QWidget* editor) {
+		QWidget* sigval1 = editor;
+		miqt_exec_callback_QAbstractItemDelegate_commitData(slot, sigval1);
+	});
+}
+
+void QAbstractItemDelegate_closeEditor(QAbstractItemDelegate* self, QWidget* editor) {
+	self->closeEditor(editor);
+}
+
+void QAbstractItemDelegate_connect_closeEditor(QAbstractItemDelegate* self, intptr_t slot) {
+	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor) {
+		QWidget* sigval1 = editor;
+		miqt_exec_callback_QAbstractItemDelegate_closeEditor(slot, sigval1);
+	});
+}
+
+void QAbstractItemDelegate_sizeHintChanged(QAbstractItemDelegate* self, QModelIndex* param1) {
+	self->sizeHintChanged(*param1);
+}
+
+void QAbstractItemDelegate_connect_sizeHintChanged(QAbstractItemDelegate* self, intptr_t slot) {
+	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(const QModelIndex&)>(&QAbstractItemDelegate::sizeHintChanged), self, [=](const QModelIndex& param1) {
+		const QModelIndex& param1_ret = param1;
+		// Cast returned reference into pointer
+		QModelIndex* sigval1 = const_cast<QModelIndex*>(&param1_ret);
+		miqt_exec_callback_QAbstractItemDelegate_sizeHintChanged(slot, sigval1);
+	});
+}
+
+struct miqt_string QAbstractItemDelegate_tr2(const char* s, const char* c) {
+	QString _ret = QAbstractItemDelegate::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAbstractItemDelegate_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAbstractItemDelegate::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAbstractItemDelegate_closeEditor2(QAbstractItemDelegate* self, QWidget* editor, int hint) {
+	self->closeEditor(editor, static_cast<QAbstractItemDelegate::EndEditHint>(hint));
+}
+
+void QAbstractItemDelegate_connect_closeEditor2(QAbstractItemDelegate* self, intptr_t slot) {
+	QAbstractItemDelegate::connect(self, static_cast<void (QAbstractItemDelegate::*)(QWidget*, QAbstractItemDelegate::EndEditHint)>(&QAbstractItemDelegate::closeEditor), self, [=](QWidget* editor, QAbstractItemDelegate::EndEditHint hint) {
+		QWidget* sigval1 = editor;
+		QAbstractItemDelegate::EndEditHint hint_ret = hint;
+		int sigval2 = static_cast<int>(hint_ret);
+		miqt_exec_callback_QAbstractItemDelegate_closeEditor2(slot, sigval1, sigval2);
+	});
+}
+
+bool QAbstractItemDelegate_override_virtual_paint(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__paint = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_override_virtual_sizeHint(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__sizeHint = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_override_virtual_createEditor(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__createEditor = slot;
+	return true;
+}
+
+QWidget* QAbstractItemDelegate_virtualbase_createEditor(const void* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index) {
+	return static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::createEditor(parent, *option, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_destroyEditor(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__destroyEditor = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_destroyEditor(const void* self, QWidget* editor, QModelIndex* index) {
+	static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::destroyEditor(editor, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_setEditorData(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__setEditorData = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_setEditorData(const void* self, QWidget* editor, QModelIndex* index) {
+	static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::setEditorData(editor, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_setModelData(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__setModelData = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_setModelData(const void* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index) {
+	static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::setModelData(editor, model, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_updateEditorGeometry(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__updateEditorGeometry = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_updateEditorGeometry(const void* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index) {
+	static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::updateEditorGeometry(editor, *option, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_editorEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__editorEvent = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_virtualbase_editorEvent(void* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index) {
+	return static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::editorEvent(event, model, *option, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_helpEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__helpEvent = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_virtualbase_helpEvent(void* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index) {
+	return static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::helpEvent(event, view, *option, *index);
+}
+
+bool QAbstractItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__paintingRoles = slot;
+	return true;
+}
+
+struct miqt_array /* of int */  QAbstractItemDelegate_virtualbase_paintingRoles(const void* self) {
+	QList<int> _ret = static_cast<const MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::paintingRoles();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	int* _arr = static_cast<int*>(malloc(sizeof(int) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+bool QAbstractItemDelegate_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::event(event);
+}
+
+bool QAbstractItemDelegate_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAbstractItemDelegate_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::eventFilter(watched, event);
+}
+
+bool QAbstractItemDelegate_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::timerEvent(event);
+}
+
+bool QAbstractItemDelegate_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::childEvent(event);
+}
+
+bool QAbstractItemDelegate_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::customEvent(event);
+}
+
+bool QAbstractItemDelegate_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::connectNotify(*signal);
+}
+
+bool QAbstractItemDelegate_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAbstractItemDelegate_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAbstractItemDelegate*>(self)->QAbstractItemDelegate::disconnectNotify(*signal);
+}
+
+QObject* QAbstractItemDelegate_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAbstractItemDelegate_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAbstractItemDelegate_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAbstractItemDelegate_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAbstractItemDelegate* self_cast = dynamic_cast<MiqtVirtualQAbstractItemDelegate*>( (QAbstractItemDelegate*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAbstractItemDelegate_delete(QAbstractItemDelegate* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qabstractitemdelegate.go

@@ -0,0 +1,805 @@
+package qt6
+
+/*
+
+#include "gen_qabstractitemdelegate.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAbstractItemDelegate__EndEditHint int
+
+const (
+	QAbstractItemDelegate__NoHint           QAbstractItemDelegate__EndEditHint = 0
+	QAbstractItemDelegate__EditNextItem     QAbstractItemDelegate__EndEditHint = 1
+	QAbstractItemDelegate__EditPreviousItem QAbstractItemDelegate__EndEditHint = 2
+	QAbstractItemDelegate__SubmitModelCache QAbstractItemDelegate__EndEditHint = 3
+	QAbstractItemDelegate__RevertModelCache QAbstractItemDelegate__EndEditHint = 4
+)
+
+type QAbstractItemDelegate struct {
+	h *C.QAbstractItemDelegate
+	*QObject
+}
+
+func (this *QAbstractItemDelegate) cPointer() *C.QAbstractItemDelegate {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAbstractItemDelegate) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAbstractItemDelegate constructs the type using only CGO pointers.
+func newQAbstractItemDelegate(h *C.QAbstractItemDelegate) *QAbstractItemDelegate {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QAbstractItemDelegate_virtbase(h, &outptr_QObject)
+
+	return &QAbstractItemDelegate{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQAbstractItemDelegate constructs the type using only unsafe pointers.
+func UnsafeNewQAbstractItemDelegate(h unsafe.Pointer) *QAbstractItemDelegate {
+	return newQAbstractItemDelegate((*C.QAbstractItemDelegate)(h))
+}
+
+// NewQAbstractItemDelegate constructs a new QAbstractItemDelegate object.
+func NewQAbstractItemDelegate() *QAbstractItemDelegate {
+
+	return newQAbstractItemDelegate(C.QAbstractItemDelegate_new())
+}
+
+// NewQAbstractItemDelegate2 constructs a new QAbstractItemDelegate object.
+func NewQAbstractItemDelegate2(parent *QObject) *QAbstractItemDelegate {
+
+	return newQAbstractItemDelegate(C.QAbstractItemDelegate_new2(parent.cPointer()))
+}
+
+func (this *QAbstractItemDelegate) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAbstractItemDelegate_metaObject(this.h))
+}
+
+func (this *QAbstractItemDelegate) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAbstractItemDelegate_metacast(this.h, param1_Cstring))
+}
+
+func QAbstractItemDelegate_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractItemDelegate_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAbstractItemDelegate) Paint(painter *QPainter, option *QStyleOptionViewItem, index *QModelIndex) {
+	C.QAbstractItemDelegate_paint(this.h, painter.cPointer(), option.cPointer(), index.cPointer())
+}
+
+func (this *QAbstractItemDelegate) SizeHint(option *QStyleOptionViewItem, index *QModelIndex) *QSize {
+	_goptr := newQSize(C.QAbstractItemDelegate_sizeHint(this.h, option.cPointer(), index.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAbstractItemDelegate) CreateEditor(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget {
+	return newQWidget(C.QAbstractItemDelegate_createEditor(this.h, parent.cPointer(), option.cPointer(), index.cPointer()))
+}
+
+func (this *QAbstractItemDelegate) DestroyEditor(editor *QWidget, index *QModelIndex) {
+	C.QAbstractItemDelegate_destroyEditor(this.h, editor.cPointer(), index.cPointer())
+}
+
+func (this *QAbstractItemDelegate) SetEditorData(editor *QWidget, index *QModelIndex) {
+	C.QAbstractItemDelegate_setEditorData(this.h, editor.cPointer(), index.cPointer())
+}
+
+func (this *QAbstractItemDelegate) SetModelData(editor *QWidget, model *QAbstractItemModel, index *QModelIndex) {
+	C.QAbstractItemDelegate_setModelData(this.h, editor.cPointer(), model.cPointer(), index.cPointer())
+}
+
+func (this *QAbstractItemDelegate) UpdateEditorGeometry(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex) {
+	C.QAbstractItemDelegate_updateEditorGeometry(this.h, editor.cPointer(), option.cPointer(), index.cPointer())
+}
+
+func (this *QAbstractItemDelegate) EditorEvent(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool {
+	return (bool)(C.QAbstractItemDelegate_editorEvent(this.h, event.cPointer(), model.cPointer(), option.cPointer(), index.cPointer()))
+}
+
+func (this *QAbstractItemDelegate) HelpEvent(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool {
+	return (bool)(C.QAbstractItemDelegate_helpEvent(this.h, event.cPointer(), view.cPointer(), option.cPointer(), index.cPointer()))
+}
+
+func (this *QAbstractItemDelegate) PaintingRoles() []int {
+	var _ma C.struct_miqt_array = C.QAbstractItemDelegate_paintingRoles(this.h)
+	_ret := make([]int, int(_ma.len))
+	_outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = (int)(_outCast[i])
+	}
+	return _ret
+}
+
+func (this *QAbstractItemDelegate) CommitData(editor *QWidget) {
+	C.QAbstractItemDelegate_commitData(this.h, editor.cPointer())
+}
+func (this *QAbstractItemDelegate) OnCommitData(slot func(editor *QWidget)) {
+	C.QAbstractItemDelegate_connect_commitData(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_commitData
+func miqt_exec_callback_QAbstractItemDelegate_commitData(cb C.intptr_t, editor *C.QWidget) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(editor *QWidget))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	gofunc(slotval1)
+}
+
+func (this *QAbstractItemDelegate) CloseEditor(editor *QWidget) {
+	C.QAbstractItemDelegate_closeEditor(this.h, editor.cPointer())
+}
+func (this *QAbstractItemDelegate) OnCloseEditor(slot func(editor *QWidget)) {
+	C.QAbstractItemDelegate_connect_closeEditor(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_closeEditor
+func miqt_exec_callback_QAbstractItemDelegate_closeEditor(cb C.intptr_t, editor *C.QWidget) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(editor *QWidget))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	gofunc(slotval1)
+}
+
+func (this *QAbstractItemDelegate) SizeHintChanged(param1 *QModelIndex) {
+	C.QAbstractItemDelegate_sizeHintChanged(this.h, param1.cPointer())
+}
+func (this *QAbstractItemDelegate) OnSizeHintChanged(slot func(param1 *QModelIndex)) {
+	C.QAbstractItemDelegate_connect_sizeHintChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_sizeHintChanged
+func miqt_exec_callback_QAbstractItemDelegate_sizeHintChanged(cb C.intptr_t, param1 *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(param1 *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQModelIndex(param1)
+
+	gofunc(slotval1)
+}
+
+func QAbstractItemDelegate_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractItemDelegate_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAbstractItemDelegate_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAbstractItemDelegate_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAbstractItemDelegate) CloseEditor2(editor *QWidget, hint QAbstractItemDelegate__EndEditHint) {
+	C.QAbstractItemDelegate_closeEditor2(this.h, editor.cPointer(), (C.int)(hint))
+}
+func (this *QAbstractItemDelegate) OnCloseEditor2(slot func(editor *QWidget, hint QAbstractItemDelegate__EndEditHint)) {
+	C.QAbstractItemDelegate_connect_closeEditor2(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_closeEditor2
+func miqt_exec_callback_QAbstractItemDelegate_closeEditor2(cb C.intptr_t, editor *C.QWidget, hint C.int) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(editor *QWidget, hint QAbstractItemDelegate__EndEditHint))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	slotval2 := (QAbstractItemDelegate__EndEditHint)(hint)
+
+	gofunc(slotval1, slotval2)
+}
+
+// Sender can only be called from a QAbstractItemDelegate that was directly constructed.
+func (this *QAbstractItemDelegate) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QAbstractItemDelegate_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QAbstractItemDelegate that was directly constructed.
+func (this *QAbstractItemDelegate) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAbstractItemDelegate_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QAbstractItemDelegate that was directly constructed.
+func (this *QAbstractItemDelegate) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAbstractItemDelegate_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QAbstractItemDelegate that was directly constructed.
+func (this *QAbstractItemDelegate) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QAbstractItemDelegate_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+func (this *QAbstractItemDelegate) OnPaint(slot func(painter *QPainter, option *QStyleOptionViewItem, index *QModelIndex)) {
+	ok := C.QAbstractItemDelegate_override_virtual_paint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_paint
+func miqt_exec_callback_QAbstractItemDelegate_paint(self *C.QAbstractItemDelegate, cb C.intptr_t, painter *C.QPainter, option *C.QStyleOptionViewItem, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(painter *QPainter, option *QStyleOptionViewItem, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQPainter(painter)
+
+	slotval2 := newQStyleOptionViewItem(option)
+
+	slotval3 := newQModelIndex(index)
+
+	gofunc(slotval1, slotval2, slotval3)
+
+}
+func (this *QAbstractItemDelegate) OnSizeHint(slot func(option *QStyleOptionViewItem, index *QModelIndex) *QSize) {
+	ok := C.QAbstractItemDelegate_override_virtual_sizeHint(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_sizeHint
+func miqt_exec_callback_QAbstractItemDelegate_sizeHint(self *C.QAbstractItemDelegate, cb C.intptr_t, option *C.QStyleOptionViewItem, index *C.QModelIndex) *C.QSize {
+	gofunc, ok := cgo.Handle(cb).Value().(func(option *QStyleOptionViewItem, index *QModelIndex) *QSize)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQStyleOptionViewItem(option)
+
+	slotval2 := newQModelIndex(index)
+
+	virtualReturn := gofunc(slotval1, slotval2)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_CreateEditor(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget {
+
+	return newQWidget(C.QAbstractItemDelegate_virtualbase_createEditor(unsafe.Pointer(this.h), parent.cPointer(), option.cPointer(), index.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnCreateEditor(slot func(super func(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget, parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget) {
+	ok := C.QAbstractItemDelegate_override_virtual_createEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_createEditor
+func miqt_exec_callback_QAbstractItemDelegate_createEditor(self *C.QAbstractItemDelegate, cb C.intptr_t, parent *C.QWidget, option *C.QStyleOptionViewItem, index *C.QModelIndex) *C.QWidget {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget, parent *QWidget, option *QStyleOptionViewItem, index *QModelIndex) *QWidget)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(parent)
+
+	slotval2 := newQStyleOptionViewItem(option)
+
+	slotval3 := newQModelIndex(index)
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_CreateEditor, slotval1, slotval2, slotval3)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_DestroyEditor(editor *QWidget, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_destroyEditor(unsafe.Pointer(this.h), editor.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnDestroyEditor(slot func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex)) {
+	ok := C.QAbstractItemDelegate_override_virtual_destroyEditor(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_destroyEditor
+func miqt_exec_callback_QAbstractItemDelegate_destroyEditor(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	slotval2 := newQModelIndex(index)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_DestroyEditor, slotval1, slotval2)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_SetEditorData(editor *QWidget, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_setEditorData(unsafe.Pointer(this.h), editor.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnSetEditorData(slot func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex)) {
+	ok := C.QAbstractItemDelegate_override_virtual_setEditorData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_setEditorData
+func miqt_exec_callback_QAbstractItemDelegate_setEditorData(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, index *QModelIndex), editor *QWidget, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	slotval2 := newQModelIndex(index)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_SetEditorData, slotval1, slotval2)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_SetModelData(editor *QWidget, model *QAbstractItemModel, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_setModelData(unsafe.Pointer(this.h), editor.cPointer(), model.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnSetModelData(slot func(super func(editor *QWidget, model *QAbstractItemModel, index *QModelIndex), editor *QWidget, model *QAbstractItemModel, index *QModelIndex)) {
+	ok := C.QAbstractItemDelegate_override_virtual_setModelData(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_setModelData
+func miqt_exec_callback_QAbstractItemDelegate_setModelData(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, model *C.QAbstractItemModel, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, model *QAbstractItemModel, index *QModelIndex), editor *QWidget, model *QAbstractItemModel, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	slotval2 := newQAbstractItemModel(model)
+
+	slotval3 := newQModelIndex(index)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_SetModelData, slotval1, slotval2, slotval3)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_UpdateEditorGeometry(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex) {
+
+	C.QAbstractItemDelegate_virtualbase_updateEditorGeometry(unsafe.Pointer(this.h), editor.cPointer(), option.cPointer(), index.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnUpdateEditorGeometry(slot func(super func(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex), editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex)) {
+	ok := C.QAbstractItemDelegate_override_virtual_updateEditorGeometry(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_updateEditorGeometry
+func miqt_exec_callback_QAbstractItemDelegate_updateEditorGeometry(self *C.QAbstractItemDelegate, cb C.intptr_t, editor *C.QWidget, option *C.QStyleOptionViewItem, index *C.QModelIndex) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex), editor *QWidget, option *QStyleOptionViewItem, index *QModelIndex))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(editor)
+
+	slotval2 := newQStyleOptionViewItem(option)
+
+	slotval3 := newQModelIndex(index)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_UpdateEditorGeometry, slotval1, slotval2, slotval3)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_EditorEvent(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_editorEvent(unsafe.Pointer(this.h), event.cPointer(), model.cPointer(), option.cPointer(), index.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEditorEvent(slot func(super func(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool) {
+	ok := C.QAbstractItemDelegate_override_virtual_editorEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_editorEvent
+func miqt_exec_callback_QAbstractItemDelegate_editorEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent, model *C.QAbstractItemModel, option *C.QStyleOptionViewItem, index *C.QModelIndex) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QEvent, model *QAbstractItemModel, option *QStyleOptionViewItem, index *QModelIndex) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQEvent(event)
+
+	slotval2 := newQAbstractItemModel(model)
+
+	slotval3 := newQStyleOptionViewItem(option)
+
+	slotval4 := newQModelIndex(index)
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_EditorEvent, slotval1, slotval2, slotval3, slotval4)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_HelpEvent(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_helpEvent(unsafe.Pointer(this.h), event.cPointer(), view.cPointer(), option.cPointer(), index.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnHelpEvent(slot func(super func(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool) {
+	ok := C.QAbstractItemDelegate_override_virtual_helpEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_helpEvent
+func miqt_exec_callback_QAbstractItemDelegate_helpEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QHelpEvent, view *C.QAbstractItemView, option *C.QStyleOptionViewItem, index *C.QModelIndex) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool, event *QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *QModelIndex) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQHelpEvent(event)
+
+	slotval2 := newQAbstractItemView(view)
+
+	slotval3 := newQStyleOptionViewItem(option)
+
+	slotval4 := newQModelIndex(index)
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_HelpEvent, slotval1, slotval2, slotval3, slotval4)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_PaintingRoles() []int {
+
+	var _ma C.struct_miqt_array = C.QAbstractItemDelegate_virtualbase_paintingRoles(unsafe.Pointer(this.h))
+	_ret := make([]int, int(_ma.len))
+	_outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = (int)(_outCast[i])
+	}
+	return _ret
+
+}
+func (this *QAbstractItemDelegate) OnPaintingRoles(slot func(super func() []int) []int) {
+	ok := C.QAbstractItemDelegate_override_virtual_paintingRoles(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_paintingRoles
+func miqt_exec_callback_QAbstractItemDelegate_paintingRoles(self *C.QAbstractItemDelegate, cb C.intptr_t) C.struct_miqt_array {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func() []int) []int)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_PaintingRoles)
+	virtualReturn_CArray := (*[0xffff]C.int)(C.malloc(C.size_t(8 * len(virtualReturn))))
+	defer C.free(unsafe.Pointer(virtualReturn_CArray))
+	for i := range virtualReturn {
+		virtualReturn_CArray[i] = (C.int)(virtualReturn[i])
+	}
+	virtualReturn_ma := C.struct_miqt_array{len: C.size_t(len(virtualReturn)), data: unsafe.Pointer(virtualReturn_CArray)}
+
+	return virtualReturn_ma
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	ok := C.QAbstractItemDelegate_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_event
+func miqt_exec_callback_QAbstractItemDelegate_event(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent) bool, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAbstractItemDelegate_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAbstractItemDelegate) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QAbstractItemDelegate_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_eventFilter
+func miqt_exec_callback_QAbstractItemDelegate_eventFilter(self *C.QAbstractItemDelegate, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QAbstractItemDelegate_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_timerEvent
+func miqt_exec_callback_QAbstractItemDelegate_timerEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QTimerEvent), event *QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQTimerEvent(event)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QAbstractItemDelegate_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_childEvent
+func miqt_exec_callback_QAbstractItemDelegate_childEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QChildEvent), event *QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQChildEvent(event)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAbstractItemDelegate_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QAbstractItemDelegate_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_customEvent
+func miqt_exec_callback_QAbstractItemDelegate_customEvent(self *C.QAbstractItemDelegate, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *QEvent), event *QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQEvent(event)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractItemDelegate_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAbstractItemDelegate_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_connectNotify
+func miqt_exec_callback_QAbstractItemDelegate_connectNotify(self *C.QAbstractItemDelegate, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQMetaMethod(signal)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAbstractItemDelegate) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAbstractItemDelegate_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAbstractItemDelegate) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAbstractItemDelegate_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractItemDelegate_disconnectNotify
+func miqt_exec_callback_QAbstractItemDelegate_disconnectNotify(self *C.QAbstractItemDelegate, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *QMetaMethod), signal *QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQMetaMethod(signal)
+
+	gofunc((&QAbstractItemDelegate{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAbstractItemDelegate) Delete() {
+	C.QAbstractItemDelegate_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAbstractItemDelegate) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAbstractItemDelegate) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qabstractitemdelegate.h

@@ -0,0 +1,124 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTITEMDELEGATE_H
+#define MIQT_QT6_GEN_QABSTRACTITEMDELEGATE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemDelegate;
+class QAbstractItemModel;
+class QAbstractItemView;
+class QChildEvent;
+class QEvent;
+class QHelpEvent;
+class QMetaMethod;
+class QMetaObject;
+class QModelIndex;
+class QObject;
+class QPainter;
+class QSize;
+class QStyleOptionViewItem;
+class QTimerEvent;
+class QWidget;
+#else
+typedef struct QAbstractItemDelegate QAbstractItemDelegate;
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractItemView QAbstractItemView;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QHelpEvent QHelpEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QModelIndex QModelIndex;
+typedef struct QObject QObject;
+typedef struct QPainter QPainter;
+typedef struct QSize QSize;
+typedef struct QStyleOptionViewItem QStyleOptionViewItem;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractItemDelegate* QAbstractItemDelegate_new();
+QAbstractItemDelegate* QAbstractItemDelegate_new2(QObject* parent);
+void QAbstractItemDelegate_virtbase(QAbstractItemDelegate* src, QObject** outptr_QObject);
+QMetaObject* QAbstractItemDelegate_metaObject(const QAbstractItemDelegate* self);
+void* QAbstractItemDelegate_metacast(QAbstractItemDelegate* self, const char* param1);
+struct miqt_string QAbstractItemDelegate_tr(const char* s);
+void QAbstractItemDelegate_paint(const QAbstractItemDelegate* self, QPainter* painter, QStyleOptionViewItem* option, QModelIndex* index);
+QSize* QAbstractItemDelegate_sizeHint(const QAbstractItemDelegate* self, QStyleOptionViewItem* option, QModelIndex* index);
+QWidget* QAbstractItemDelegate_createEditor(const QAbstractItemDelegate* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index);
+void QAbstractItemDelegate_destroyEditor(const QAbstractItemDelegate* self, QWidget* editor, QModelIndex* index);
+void QAbstractItemDelegate_setEditorData(const QAbstractItemDelegate* self, QWidget* editor, QModelIndex* index);
+void QAbstractItemDelegate_setModelData(const QAbstractItemDelegate* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index);
+void QAbstractItemDelegate_updateEditorGeometry(const QAbstractItemDelegate* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_editorEvent(QAbstractItemDelegate* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_helpEvent(QAbstractItemDelegate* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index);
+struct miqt_array /* of int */  QAbstractItemDelegate_paintingRoles(const QAbstractItemDelegate* self);
+void QAbstractItemDelegate_commitData(QAbstractItemDelegate* self, QWidget* editor);
+void QAbstractItemDelegate_connect_commitData(QAbstractItemDelegate* self, intptr_t slot);
+void QAbstractItemDelegate_closeEditor(QAbstractItemDelegate* self, QWidget* editor);
+void QAbstractItemDelegate_connect_closeEditor(QAbstractItemDelegate* self, intptr_t slot);
+void QAbstractItemDelegate_sizeHintChanged(QAbstractItemDelegate* self, QModelIndex* param1);
+void QAbstractItemDelegate_connect_sizeHintChanged(QAbstractItemDelegate* self, intptr_t slot);
+struct miqt_string QAbstractItemDelegate_tr2(const char* s, const char* c);
+struct miqt_string QAbstractItemDelegate_tr3(const char* s, const char* c, int n);
+void QAbstractItemDelegate_closeEditor2(QAbstractItemDelegate* self, QWidget* editor, int hint);
+void QAbstractItemDelegate_connect_closeEditor2(QAbstractItemDelegate* self, intptr_t slot);
+
+bool QAbstractItemDelegate_override_virtual_paint(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_paint(const void* self, QPainter* painter, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractItemDelegate_virtualbase_sizeHint(const void* self, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_createEditor(void* self, intptr_t slot);
+QWidget* QAbstractItemDelegate_virtualbase_createEditor(const void* self, QWidget* parent, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_destroyEditor(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_destroyEditor(const void* self, QWidget* editor, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_setEditorData(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_setEditorData(const void* self, QWidget* editor, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_setModelData(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_setModelData(const void* self, QWidget* editor, QAbstractItemModel* model, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_updateEditorGeometry(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_updateEditorGeometry(const void* self, QWidget* editor, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_editorEvent(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_editorEvent(void* self, QEvent* event, QAbstractItemModel* model, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_helpEvent(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_helpEvent(void* self, QHelpEvent* event, QAbstractItemView* view, QStyleOptionViewItem* option, QModelIndex* index);
+bool QAbstractItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slot);
+struct miqt_array /* of int */  QAbstractItemDelegate_virtualbase_paintingRoles(const void* self);
+bool QAbstractItemDelegate_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_event(void* self, QEvent* event);
+bool QAbstractItemDelegate_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractItemDelegate_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractItemDelegate_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractItemDelegate_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractItemDelegate_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractItemDelegate_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractItemDelegate_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractItemDelegate_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAbstractItemDelegate_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemDelegate_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemDelegate_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractItemDelegate_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractItemDelegate_delete(QAbstractItemDelegate* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractitemmodel.h

@@ -0,0 +1,593 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTITEMMODEL_H
+#define MIQT_QT6_GEN_QABSTRACTITEMMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractListModel;
+class QAbstractTableModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QModelRoleData;
+class QModelRoleDataSpan;
+class QObject;
+class QPersistentModelIndex;
+class QSize;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractListModel QAbstractListModel;
+typedef struct QAbstractTableModel QAbstractTableModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QModelRoleData QModelRoleData;
+typedef struct QModelRoleDataSpan QModelRoleDataSpan;
+typedef struct QObject QObject;
+typedef struct QPersistentModelIndex QPersistentModelIndex;
+typedef struct QSize QSize;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QModelRoleData* QModelRoleData_new(int role);
+QModelRoleData* QModelRoleData_new2(QModelRoleData* param1);
+int QModelRoleData_role(const QModelRoleData* self);
+QVariant* QModelRoleData_data(QModelRoleData* self);
+QVariant* QModelRoleData_data2(const QModelRoleData* self);
+void QModelRoleData_clearData(QModelRoleData* self);
+void QModelRoleData_operatorAssign(QModelRoleData* self, QModelRoleData* param1);
+
+void QModelRoleData_delete(QModelRoleData* self);
+
+QModelRoleDataSpan* QModelRoleDataSpan_new();
+QModelRoleDataSpan* QModelRoleDataSpan_new2(QModelRoleData* modelRoleData);
+QModelRoleDataSpan* QModelRoleDataSpan_new3(QModelRoleData* modelRoleData, ptrdiff_t len);
+QModelRoleDataSpan* QModelRoleDataSpan_new4(QModelRoleDataSpan* param1);
+ptrdiff_t QModelRoleDataSpan_size(const QModelRoleDataSpan* self);
+ptrdiff_t QModelRoleDataSpan_length(const QModelRoleDataSpan* self);
+QModelRoleData* QModelRoleDataSpan_data(const QModelRoleDataSpan* self);
+QModelRoleData* QModelRoleDataSpan_begin(const QModelRoleDataSpan* self);
+QModelRoleData* QModelRoleDataSpan_end(const QModelRoleDataSpan* self);
+QModelRoleData* QModelRoleDataSpan_operatorSubscript(const QModelRoleDataSpan* self, ptrdiff_t index);
+QVariant* QModelRoleDataSpan_dataForRole(const QModelRoleDataSpan* self, int role);
+
+void QModelRoleDataSpan_delete(QModelRoleDataSpan* self);
+
+QModelIndex* QModelIndex_new();
+QModelIndex* QModelIndex_new2(QModelIndex* param1);
+int QModelIndex_row(const QModelIndex* self);
+int QModelIndex_column(const QModelIndex* self);
+uintptr_t QModelIndex_internalId(const QModelIndex* self);
+void* QModelIndex_internalPointer(const QModelIndex* self);
+const void* QModelIndex_constInternalPointer(const QModelIndex* self);
+QModelIndex* QModelIndex_parent(const QModelIndex* self);
+QModelIndex* QModelIndex_sibling(const QModelIndex* self, int row, int column);
+QModelIndex* QModelIndex_siblingAtColumn(const QModelIndex* self, int column);
+QModelIndex* QModelIndex_siblingAtRow(const QModelIndex* self, int row);
+QVariant* QModelIndex_data(const QModelIndex* self);
+void QModelIndex_multiData(const QModelIndex* self, QModelRoleDataSpan* roleDataSpan);
+int QModelIndex_flags(const QModelIndex* self);
+QAbstractItemModel* QModelIndex_model(const QModelIndex* self);
+bool QModelIndex_isValid(const QModelIndex* self);
+bool QModelIndex_operatorEqual(const QModelIndex* self, QModelIndex* other);
+bool QModelIndex_operatorNotEqual(const QModelIndex* self, QModelIndex* other);
+bool QModelIndex_operatorLesser(const QModelIndex* self, QModelIndex* other);
+QVariant* QModelIndex_dataWithRole(const QModelIndex* self, int role);
+
+void QModelIndex_delete(QModelIndex* self);
+
+QPersistentModelIndex* QPersistentModelIndex_new();
+QPersistentModelIndex* QPersistentModelIndex_new2(QModelIndex* index);
+QPersistentModelIndex* QPersistentModelIndex_new3(QPersistentModelIndex* other);
+bool QPersistentModelIndex_operatorLesser(const QPersistentModelIndex* self, QPersistentModelIndex* other);
+bool QPersistentModelIndex_operatorEqual(const QPersistentModelIndex* self, QPersistentModelIndex* other);
+bool QPersistentModelIndex_operatorNotEqual(const QPersistentModelIndex* self, QPersistentModelIndex* other);
+void QPersistentModelIndex_operatorAssign(QPersistentModelIndex* self, QPersistentModelIndex* other);
+void QPersistentModelIndex_swap(QPersistentModelIndex* self, QPersistentModelIndex* other);
+bool QPersistentModelIndex_operatorEqualWithOther(const QPersistentModelIndex* self, QModelIndex* other);
+bool QPersistentModelIndex_operatorNotEqualWithOther(const QPersistentModelIndex* self, QModelIndex* other);
+void QPersistentModelIndex_operatorAssignWithOther(QPersistentModelIndex* self, QModelIndex* other);
+QModelIndex* QPersistentModelIndex_ToQModelIndex(const QPersistentModelIndex* self);
+int QPersistentModelIndex_row(const QPersistentModelIndex* self);
+int QPersistentModelIndex_column(const QPersistentModelIndex* self);
+void* QPersistentModelIndex_internalPointer(const QPersistentModelIndex* self);
+const void* QPersistentModelIndex_constInternalPointer(const QPersistentModelIndex* self);
+uintptr_t QPersistentModelIndex_internalId(const QPersistentModelIndex* self);
+QModelIndex* QPersistentModelIndex_parent(const QPersistentModelIndex* self);
+QModelIndex* QPersistentModelIndex_sibling(const QPersistentModelIndex* self, int row, int column);
+QVariant* QPersistentModelIndex_data(const QPersistentModelIndex* self);
+void QPersistentModelIndex_multiData(const QPersistentModelIndex* self, QModelRoleDataSpan* roleDataSpan);
+int QPersistentModelIndex_flags(const QPersistentModelIndex* self);
+QAbstractItemModel* QPersistentModelIndex_model(const QPersistentModelIndex* self);
+bool QPersistentModelIndex_isValid(const QPersistentModelIndex* self);
+QVariant* QPersistentModelIndex_dataWithRole(const QPersistentModelIndex* self, int role);
+
+void QPersistentModelIndex_delete(QPersistentModelIndex* self);
+
+QAbstractItemModel* QAbstractItemModel_new();
+QAbstractItemModel* QAbstractItemModel_new2(QObject* parent);
+void QAbstractItemModel_virtbase(QAbstractItemModel* src, QObject** outptr_QObject);
+QMetaObject* QAbstractItemModel_metaObject(const QAbstractItemModel* self);
+void* QAbstractItemModel_metacast(QAbstractItemModel* self, const char* param1);
+struct miqt_string QAbstractItemModel_tr(const char* s);
+bool QAbstractItemModel_hasIndex(const QAbstractItemModel* self, int row, int column);
+QModelIndex* QAbstractItemModel_index(const QAbstractItemModel* self, int row, int column, QModelIndex* parent);
+QModelIndex* QAbstractItemModel_parent(const QAbstractItemModel* self, QModelIndex* child);
+QModelIndex* QAbstractItemModel_sibling(const QAbstractItemModel* self, int row, int column, QModelIndex* idx);
+int QAbstractItemModel_rowCount(const QAbstractItemModel* self, QModelIndex* parent);
+int QAbstractItemModel_columnCount(const QAbstractItemModel* self, QModelIndex* parent);
+bool QAbstractItemModel_hasChildren(const QAbstractItemModel* self, QModelIndex* parent);
+QVariant* QAbstractItemModel_data(const QAbstractItemModel* self, QModelIndex* index, int role);
+bool QAbstractItemModel_setData(QAbstractItemModel* self, QModelIndex* index, QVariant* value, int role);
+QVariant* QAbstractItemModel_headerData(const QAbstractItemModel* self, int section, int orientation, int role);
+bool QAbstractItemModel_setHeaderData(QAbstractItemModel* self, int section, int orientation, QVariant* value, int role);
+struct miqt_map /* of int to QVariant* */  QAbstractItemModel_itemData(const QAbstractItemModel* self, QModelIndex* index);
+bool QAbstractItemModel_setItemData(QAbstractItemModel* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractItemModel_clearItemData(QAbstractItemModel* self, QModelIndex* index);
+struct miqt_array /* of struct miqt_string */  QAbstractItemModel_mimeTypes(const QAbstractItemModel* self);
+QMimeData* QAbstractItemModel_mimeData(const QAbstractItemModel* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractItemModel_canDropMimeData(const QAbstractItemModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractItemModel_dropMimeData(QAbstractItemModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+int QAbstractItemModel_supportedDropActions(const QAbstractItemModel* self);
+int QAbstractItemModel_supportedDragActions(const QAbstractItemModel* self);
+bool QAbstractItemModel_insertRows(QAbstractItemModel* self, int row, int count, QModelIndex* parent);
+bool QAbstractItemModel_insertColumns(QAbstractItemModel* self, int column, int count, QModelIndex* parent);
+bool QAbstractItemModel_removeRows(QAbstractItemModel* self, int row, int count, QModelIndex* parent);
+bool QAbstractItemModel_removeColumns(QAbstractItemModel* self, int column, int count, QModelIndex* parent);
+bool QAbstractItemModel_moveRows(QAbstractItemModel* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractItemModel_moveColumns(QAbstractItemModel* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractItemModel_insertRow(QAbstractItemModel* self, int row);
+bool QAbstractItemModel_insertColumn(QAbstractItemModel* self, int column);
+bool QAbstractItemModel_removeRow(QAbstractItemModel* self, int row);
+bool QAbstractItemModel_removeColumn(QAbstractItemModel* self, int column);
+bool QAbstractItemModel_moveRow(QAbstractItemModel* self, QModelIndex* sourceParent, int sourceRow, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractItemModel_moveColumn(QAbstractItemModel* self, QModelIndex* sourceParent, int sourceColumn, QModelIndex* destinationParent, int destinationChild);
+void QAbstractItemModel_fetchMore(QAbstractItemModel* self, QModelIndex* parent);
+bool QAbstractItemModel_canFetchMore(const QAbstractItemModel* self, QModelIndex* parent);
+int QAbstractItemModel_flags(const QAbstractItemModel* self, QModelIndex* index);
+void QAbstractItemModel_sort(QAbstractItemModel* self, int column, int order);
+QModelIndex* QAbstractItemModel_buddy(const QAbstractItemModel* self, QModelIndex* index);
+struct miqt_array /* of QModelIndex* */  QAbstractItemModel_match(const QAbstractItemModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+QSize* QAbstractItemModel_span(const QAbstractItemModel* self, QModelIndex* index);
+struct miqt_map /* of int to struct miqt_string */  QAbstractItemModel_roleNames(const QAbstractItemModel* self);
+bool QAbstractItemModel_checkIndex(const QAbstractItemModel* self, QModelIndex* index);
+void QAbstractItemModel_multiData(const QAbstractItemModel* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+void QAbstractItemModel_dataChanged(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight);
+void QAbstractItemModel_connect_dataChanged(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_headerDataChanged(QAbstractItemModel* self, int orientation, int first, int last);
+void QAbstractItemModel_connect_headerDataChanged(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutChanged(QAbstractItemModel* self);
+void QAbstractItemModel_connect_layoutChanged(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutAboutToBeChanged(QAbstractItemModel* self);
+void QAbstractItemModel_connect_layoutAboutToBeChanged(QAbstractItemModel* self, intptr_t slot);
+bool QAbstractItemModel_submit(QAbstractItemModel* self);
+void QAbstractItemModel_revert(QAbstractItemModel* self);
+void QAbstractItemModel_resetInternalData(QAbstractItemModel* self);
+struct miqt_string QAbstractItemModel_tr2(const char* s, const char* c);
+struct miqt_string QAbstractItemModel_tr3(const char* s, const char* c, int n);
+bool QAbstractItemModel_hasIndex2(const QAbstractItemModel* self, int row, int column, QModelIndex* parent);
+bool QAbstractItemModel_insertRow2(QAbstractItemModel* self, int row, QModelIndex* parent);
+bool QAbstractItemModel_insertColumn2(QAbstractItemModel* self, int column, QModelIndex* parent);
+bool QAbstractItemModel_removeRow2(QAbstractItemModel* self, int row, QModelIndex* parent);
+bool QAbstractItemModel_removeColumn2(QAbstractItemModel* self, int column, QModelIndex* parent);
+bool QAbstractItemModel_checkIndex2(const QAbstractItemModel* self, QModelIndex* index, int options);
+void QAbstractItemModel_dataChanged2(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */  roles);
+void QAbstractItemModel_connect_dataChanged2(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutChangedWithParents(QAbstractItemModel* self, struct miqt_array /* of QPersistentModelIndex* */  parents);
+void QAbstractItemModel_connect_layoutChangedWithParents(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutChanged2(QAbstractItemModel* self, struct miqt_array /* of QPersistentModelIndex* */  parents, int hint);
+void QAbstractItemModel_connect_layoutChanged2(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutAboutToBeChangedWithParents(QAbstractItemModel* self, struct miqt_array /* of QPersistentModelIndex* */  parents);
+void QAbstractItemModel_connect_layoutAboutToBeChangedWithParents(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_layoutAboutToBeChanged2(QAbstractItemModel* self, struct miqt_array /* of QPersistentModelIndex* */  parents, int hint);
+void QAbstractItemModel_connect_layoutAboutToBeChanged2(QAbstractItemModel* self, intptr_t slot);
+
+bool QAbstractItemModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_parent(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_parent(const void* self, QModelIndex* child);
+bool QAbstractItemModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QAbstractItemModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_hasChildren(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_hasChildren(const void* self, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QAbstractItemModel_virtualbase_data(const void* self, QModelIndex* index, int role);
+bool QAbstractItemModel_override_virtual_setData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QAbstractItemModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QAbstractItemModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QAbstractItemModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QAbstractItemModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractItemModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QAbstractItemModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractItemModel_override_virtual_clearItemData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_clearItemData(void* self, QModelIndex* index);
+bool QAbstractItemModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractItemModel_virtualbase_mimeTypes(const void* self);
+bool QAbstractItemModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QAbstractItemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractItemModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_supportedDropActions(const void* self);
+bool QAbstractItemModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_supportedDragActions(const void* self);
+bool QAbstractItemModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractItemModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractItemModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QAbstractItemModel_override_virtual_flags(void* self, intptr_t slot);
+int QAbstractItemModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QAbstractItemModel_override_virtual_sort(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_sort(void* self, int column, int order);
+bool QAbstractItemModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractItemModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QAbstractItemModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractItemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QAbstractItemModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QAbstractItemModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QAbstractItemModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractItemModel_virtualbase_roleNames(const void* self);
+bool QAbstractItemModel_override_virtual_multiData(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+bool QAbstractItemModel_override_virtual_submit(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_submit(void* self);
+bool QAbstractItemModel_override_virtual_revert(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_revert(void* self);
+bool QAbstractItemModel_override_virtual_resetInternalData(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_resetInternalData(void* self);
+bool QAbstractItemModel_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_event(void* self, QEvent* event);
+bool QAbstractItemModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractItemModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractItemModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractItemModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractItemModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractItemModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractItemModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractItemModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QModelIndex* QAbstractItemModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+QModelIndex* QAbstractItemModel_protectedbase_createIndex2(bool* _dynamic_cast_ok, const void* self, int row, int column, uintptr_t id);
+void QAbstractItemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QAbstractItemModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+void QAbstractItemModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractItemModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractItemModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+bool QAbstractItemModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QAbstractItemModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractItemModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractItemModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+bool QAbstractItemModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QAbstractItemModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QAbstractItemModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QAbstractItemModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QModelIndex* QAbstractItemModel_protectedbase_createIndex3(bool* _dynamic_cast_ok, const void* self, int row, int column, const void* data);
+QObject* QAbstractItemModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractItemModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractItemModel_connect_rowsAboutToBeInserted(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_rowsInserted(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_rowsAboutToBeRemoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_rowsRemoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsAboutToBeInserted(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsInserted(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsAboutToBeRemoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsRemoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_modelAboutToBeReset(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_modelReset(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_rowsAboutToBeMoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_rowsMoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsAboutToBeMoved(QAbstractItemModel* self, intptr_t slot);
+void QAbstractItemModel_connect_columnsMoved(QAbstractItemModel* self, intptr_t slot);
+
+void QAbstractItemModel_delete(QAbstractItemModel* self);
+
+QAbstractTableModel* QAbstractTableModel_new();
+QAbstractTableModel* QAbstractTableModel_new2(QObject* parent);
+void QAbstractTableModel_virtbase(QAbstractTableModel* src, QAbstractItemModel** outptr_QAbstractItemModel);
+QMetaObject* QAbstractTableModel_metaObject(const QAbstractTableModel* self);
+void* QAbstractTableModel_metacast(QAbstractTableModel* self, const char* param1);
+struct miqt_string QAbstractTableModel_tr(const char* s);
+QModelIndex* QAbstractTableModel_index(const QAbstractTableModel* self, int row, int column, QModelIndex* parent);
+QModelIndex* QAbstractTableModel_sibling(const QAbstractTableModel* self, int row, int column, QModelIndex* idx);
+bool QAbstractTableModel_dropMimeData(QAbstractTableModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+int QAbstractTableModel_flags(const QAbstractTableModel* self, QModelIndex* index);
+struct miqt_string QAbstractTableModel_tr2(const char* s, const char* c);
+struct miqt_string QAbstractTableModel_tr3(const char* s, const char* c, int n);
+
+bool QAbstractTableModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QAbstractTableModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_flags(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QAbstractTableModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QAbstractTableModel_virtualbase_data(const void* self, QModelIndex* index, int role);
+bool QAbstractTableModel_override_virtual_setData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QAbstractTableModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QAbstractTableModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QAbstractTableModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QAbstractTableModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractTableModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QAbstractTableModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractTableModel_override_virtual_clearItemData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_clearItemData(void* self, QModelIndex* index);
+bool QAbstractTableModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractTableModel_virtualbase_mimeTypes(const void* self);
+bool QAbstractTableModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QAbstractTableModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractTableModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_supportedDropActions(const void* self);
+bool QAbstractTableModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QAbstractTableModel_virtualbase_supportedDragActions(const void* self);
+bool QAbstractTableModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractTableModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractTableModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QAbstractTableModel_override_virtual_sort(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_sort(void* self, int column, int order);
+bool QAbstractTableModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractTableModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QAbstractTableModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractTableModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QAbstractTableModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QAbstractTableModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QAbstractTableModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractTableModel_virtualbase_roleNames(const void* self);
+bool QAbstractTableModel_override_virtual_multiData(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+bool QAbstractTableModel_override_virtual_submit(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_submit(void* self);
+bool QAbstractTableModel_override_virtual_revert(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_revert(void* self);
+bool QAbstractTableModel_override_virtual_resetInternalData(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_resetInternalData(void* self);
+bool QAbstractTableModel_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_event(void* self, QEvent* event);
+bool QAbstractTableModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractTableModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractTableModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractTableModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractTableModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractTableModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractTableModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractTableModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QModelIndex* QAbstractTableModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QAbstractTableModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QAbstractTableModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+void QAbstractTableModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractTableModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractTableModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+bool QAbstractTableModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QAbstractTableModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractTableModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractTableModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+bool QAbstractTableModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QAbstractTableModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractTableModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QAbstractTableModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QAbstractTableModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QAbstractTableModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractTableModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractTableModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractTableModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractTableModel_delete(QAbstractTableModel* self);
+
+QAbstractListModel* QAbstractListModel_new();
+QAbstractListModel* QAbstractListModel_new2(QObject* parent);
+void QAbstractListModel_virtbase(QAbstractListModel* src, QAbstractItemModel** outptr_QAbstractItemModel);
+QMetaObject* QAbstractListModel_metaObject(const QAbstractListModel* self);
+void* QAbstractListModel_metacast(QAbstractListModel* self, const char* param1);
+struct miqt_string QAbstractListModel_tr(const char* s);
+QModelIndex* QAbstractListModel_index(const QAbstractListModel* self, int row, int column, QModelIndex* parent);
+QModelIndex* QAbstractListModel_sibling(const QAbstractListModel* self, int row, int column, QModelIndex* idx);
+bool QAbstractListModel_dropMimeData(QAbstractListModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+int QAbstractListModel_flags(const QAbstractListModel* self, QModelIndex* index);
+struct miqt_string QAbstractListModel_tr2(const char* s, const char* c);
+struct miqt_string QAbstractListModel_tr3(const char* s, const char* c, int n);
+
+bool QAbstractListModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QAbstractListModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_flags(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QAbstractListModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QAbstractListModel_virtualbase_data(const void* self, QModelIndex* index, int role);
+bool QAbstractListModel_override_virtual_setData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QAbstractListModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QAbstractListModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QAbstractListModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QAbstractListModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractListModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QAbstractListModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractListModel_override_virtual_clearItemData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_clearItemData(void* self, QModelIndex* index);
+bool QAbstractListModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractListModel_virtualbase_mimeTypes(const void* self);
+bool QAbstractListModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QAbstractListModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractListModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_supportedDropActions(const void* self);
+bool QAbstractListModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QAbstractListModel_virtualbase_supportedDragActions(const void* self);
+bool QAbstractListModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractListModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractListModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QAbstractListModel_override_virtual_sort(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_sort(void* self, int column, int order);
+bool QAbstractListModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractListModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QAbstractListModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractListModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QAbstractListModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QAbstractListModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QAbstractListModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractListModel_virtualbase_roleNames(const void* self);
+bool QAbstractListModel_override_virtual_multiData(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+bool QAbstractListModel_override_virtual_submit(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_submit(void* self);
+bool QAbstractListModel_override_virtual_revert(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_revert(void* self);
+bool QAbstractListModel_override_virtual_resetInternalData(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_resetInternalData(void* self);
+bool QAbstractListModel_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_event(void* self, QEvent* event);
+bool QAbstractListModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractListModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractListModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractListModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractListModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractListModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractListModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractListModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QModelIndex* QAbstractListModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QAbstractListModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QAbstractListModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+void QAbstractListModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractListModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractListModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+bool QAbstractListModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QAbstractListModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractListModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractListModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+bool QAbstractListModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QAbstractListModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractListModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QAbstractListModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QAbstractListModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QAbstractListModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractListModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractListModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractListModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractListModel_delete(QAbstractListModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractitemview.h

@@ -0,0 +1,463 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTITEMVIEW_H
+#define MIQT_QT6_GEN_QABSTRACTITEMVIEW_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemDelegate;
+class QAbstractItemModel;
+class QAbstractItemView;
+class QAbstractScrollArea;
+class QActionEvent;
+class QChildEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
+class QEnterEvent;
+class QEvent;
+class QFocusEvent;
+class QFrame;
+class QHideEvent;
+class QInputMethodEvent;
+class QItemSelection;
+class QItemSelectionModel;
+class QKeyEvent;
+class QMargins;
+class QMetaMethod;
+class QMetaObject;
+class QModelIndex;
+class QMouseEvent;
+class QMoveEvent;
+class QObject;
+class QPaintDevice;
+class QPaintEngine;
+class QPaintEvent;
+class QPainter;
+class QPoint;
+class QRect;
+class QRegion;
+class QResizeEvent;
+class QShowEvent;
+class QSize;
+class QStyleOptionFrame;
+class QStyleOptionViewItem;
+class QTabletEvent;
+class QTimerEvent;
+class QVariant;
+class QWheelEvent;
+class QWidget;
+#else
+typedef struct QAbstractItemDelegate QAbstractItemDelegate;
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractItemView QAbstractItemView;
+typedef struct QAbstractScrollArea QAbstractScrollArea;
+typedef struct QActionEvent QActionEvent;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
+typedef struct QEnterEvent QEnterEvent;
+typedef struct QEvent QEvent;
+typedef struct QFocusEvent QFocusEvent;
+typedef struct QFrame QFrame;
+typedef struct QHideEvent QHideEvent;
+typedef struct QInputMethodEvent QInputMethodEvent;
+typedef struct QItemSelection QItemSelection;
+typedef struct QItemSelectionModel QItemSelectionModel;
+typedef struct QKeyEvent QKeyEvent;
+typedef struct QMargins QMargins;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QModelIndex QModelIndex;
+typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
+typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
+typedef struct QPoint QPoint;
+typedef struct QRect QRect;
+typedef struct QRegion QRegion;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QShowEvent QShowEvent;
+typedef struct QSize QSize;
+typedef struct QStyleOptionFrame QStyleOptionFrame;
+typedef struct QStyleOptionViewItem QStyleOptionViewItem;
+typedef struct QTabletEvent QTabletEvent;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractItemView* QAbstractItemView_new(QWidget* parent);
+QAbstractItemView* QAbstractItemView_new2();
+void QAbstractItemView_virtbase(QAbstractItemView* src, QAbstractScrollArea** outptr_QAbstractScrollArea);
+QMetaObject* QAbstractItemView_metaObject(const QAbstractItemView* self);
+void* QAbstractItemView_metacast(QAbstractItemView* self, const char* param1);
+struct miqt_string QAbstractItemView_tr(const char* s);
+void QAbstractItemView_setModel(QAbstractItemView* self, QAbstractItemModel* model);
+QAbstractItemModel* QAbstractItemView_model(const QAbstractItemView* self);
+void QAbstractItemView_setSelectionModel(QAbstractItemView* self, QItemSelectionModel* selectionModel);
+QItemSelectionModel* QAbstractItemView_selectionModel(const QAbstractItemView* self);
+void QAbstractItemView_setItemDelegate(QAbstractItemView* self, QAbstractItemDelegate* delegate);
+QAbstractItemDelegate* QAbstractItemView_itemDelegate(const QAbstractItemView* self);
+void QAbstractItemView_setSelectionMode(QAbstractItemView* self, int mode);
+int QAbstractItemView_selectionMode(const QAbstractItemView* self);
+void QAbstractItemView_setSelectionBehavior(QAbstractItemView* self, int behavior);
+int QAbstractItemView_selectionBehavior(const QAbstractItemView* self);
+QModelIndex* QAbstractItemView_currentIndex(const QAbstractItemView* self);
+QModelIndex* QAbstractItemView_rootIndex(const QAbstractItemView* self);
+void QAbstractItemView_setEditTriggers(QAbstractItemView* self, int triggers);
+int QAbstractItemView_editTriggers(const QAbstractItemView* self);
+void QAbstractItemView_setVerticalScrollMode(QAbstractItemView* self, int mode);
+int QAbstractItemView_verticalScrollMode(const QAbstractItemView* self);
+void QAbstractItemView_resetVerticalScrollMode(QAbstractItemView* self);
+void QAbstractItemView_setHorizontalScrollMode(QAbstractItemView* self, int mode);
+int QAbstractItemView_horizontalScrollMode(const QAbstractItemView* self);
+void QAbstractItemView_resetHorizontalScrollMode(QAbstractItemView* self);
+void QAbstractItemView_setAutoScroll(QAbstractItemView* self, bool enable);
+bool QAbstractItemView_hasAutoScroll(const QAbstractItemView* self);
+void QAbstractItemView_setAutoScrollMargin(QAbstractItemView* self, int margin);
+int QAbstractItemView_autoScrollMargin(const QAbstractItemView* self);
+void QAbstractItemView_setTabKeyNavigation(QAbstractItemView* self, bool enable);
+bool QAbstractItemView_tabKeyNavigation(const QAbstractItemView* self);
+void QAbstractItemView_setDropIndicatorShown(QAbstractItemView* self, bool enable);
+bool QAbstractItemView_showDropIndicator(const QAbstractItemView* self);
+void QAbstractItemView_setDragEnabled(QAbstractItemView* self, bool enable);
+bool QAbstractItemView_dragEnabled(const QAbstractItemView* self);
+void QAbstractItemView_setDragDropOverwriteMode(QAbstractItemView* self, bool overwrite);
+bool QAbstractItemView_dragDropOverwriteMode(const QAbstractItemView* self);
+void QAbstractItemView_setDragDropMode(QAbstractItemView* self, int behavior);
+int QAbstractItemView_dragDropMode(const QAbstractItemView* self);
+void QAbstractItemView_setDefaultDropAction(QAbstractItemView* self, int dropAction);
+int QAbstractItemView_defaultDropAction(const QAbstractItemView* self);
+void QAbstractItemView_setAlternatingRowColors(QAbstractItemView* self, bool enable);
+bool QAbstractItemView_alternatingRowColors(const QAbstractItemView* self);
+void QAbstractItemView_setIconSize(QAbstractItemView* self, QSize* size);
+QSize* QAbstractItemView_iconSize(const QAbstractItemView* self);
+void QAbstractItemView_setTextElideMode(QAbstractItemView* self, int mode);
+int QAbstractItemView_textElideMode(const QAbstractItemView* self);
+void QAbstractItemView_keyboardSearch(QAbstractItemView* self, struct miqt_string search);
+QRect* QAbstractItemView_visualRect(const QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_scrollTo(QAbstractItemView* self, QModelIndex* index, int hint);
+QModelIndex* QAbstractItemView_indexAt(const QAbstractItemView* self, QPoint* point);
+QSize* QAbstractItemView_sizeHintForIndex(const QAbstractItemView* self, QModelIndex* index);
+int QAbstractItemView_sizeHintForRow(const QAbstractItemView* self, int row);
+int QAbstractItemView_sizeHintForColumn(const QAbstractItemView* self, int column);
+void QAbstractItemView_openPersistentEditor(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_closePersistentEditor(QAbstractItemView* self, QModelIndex* index);
+bool QAbstractItemView_isPersistentEditorOpen(const QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_setIndexWidget(QAbstractItemView* self, QModelIndex* index, QWidget* widget);
+QWidget* QAbstractItemView_indexWidget(const QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_setItemDelegateForRow(QAbstractItemView* self, int row, QAbstractItemDelegate* delegate);
+QAbstractItemDelegate* QAbstractItemView_itemDelegateForRow(const QAbstractItemView* self, int row);
+void QAbstractItemView_setItemDelegateForColumn(QAbstractItemView* self, int column, QAbstractItemDelegate* delegate);
+QAbstractItemDelegate* QAbstractItemView_itemDelegateForColumn(const QAbstractItemView* self, int column);
+QAbstractItemDelegate* QAbstractItemView_itemDelegateWithIndex(const QAbstractItemView* self, QModelIndex* index);
+QAbstractItemDelegate* QAbstractItemView_itemDelegateForIndex(const QAbstractItemView* self, QModelIndex* index);
+QVariant* QAbstractItemView_inputMethodQuery(const QAbstractItemView* self, int query);
+void QAbstractItemView_reset(QAbstractItemView* self);
+void QAbstractItemView_setRootIndex(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_doItemsLayout(QAbstractItemView* self);
+void QAbstractItemView_selectAll(QAbstractItemView* self);
+void QAbstractItemView_edit(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_clearSelection(QAbstractItemView* self);
+void QAbstractItemView_setCurrentIndex(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_scrollToTop(QAbstractItemView* self);
+void QAbstractItemView_scrollToBottom(QAbstractItemView* self);
+void QAbstractItemView_update(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_dataChanged(QAbstractItemView* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */  roles);
+void QAbstractItemView_rowsInserted(QAbstractItemView* self, QModelIndex* parent, int start, int end);
+void QAbstractItemView_rowsAboutToBeRemoved(QAbstractItemView* self, QModelIndex* parent, int start, int end);
+void QAbstractItemView_selectionChanged(QAbstractItemView* self, QItemSelection* selected, QItemSelection* deselected);
+void QAbstractItemView_currentChanged(QAbstractItemView* self, QModelIndex* current, QModelIndex* previous);
+void QAbstractItemView_updateEditorData(QAbstractItemView* self);
+void QAbstractItemView_updateEditorGeometries(QAbstractItemView* self);
+void QAbstractItemView_updateGeometries(QAbstractItemView* self);
+void QAbstractItemView_verticalScrollbarAction(QAbstractItemView* self, int action);
+void QAbstractItemView_horizontalScrollbarAction(QAbstractItemView* self, int action);
+void QAbstractItemView_verticalScrollbarValueChanged(QAbstractItemView* self, int value);
+void QAbstractItemView_horizontalScrollbarValueChanged(QAbstractItemView* self, int value);
+void QAbstractItemView_closeEditor(QAbstractItemView* self, QWidget* editor, int hint);
+void QAbstractItemView_commitData(QAbstractItemView* self, QWidget* editor);
+void QAbstractItemView_editorDestroyed(QAbstractItemView* self, QObject* editor);
+void QAbstractItemView_pressed(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_connect_pressed(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_clicked(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_connect_clicked(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_doubleClicked(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_connect_doubleClicked(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_activated(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_connect_activated(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_entered(QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_connect_entered(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_viewportEntered(QAbstractItemView* self);
+void QAbstractItemView_connect_viewportEntered(QAbstractItemView* self, intptr_t slot);
+void QAbstractItemView_iconSizeChanged(QAbstractItemView* self, QSize* size);
+void QAbstractItemView_connect_iconSizeChanged(QAbstractItemView* self, intptr_t slot);
+QModelIndex* QAbstractItemView_moveCursor(QAbstractItemView* self, int cursorAction, int modifiers);
+int QAbstractItemView_horizontalOffset(const QAbstractItemView* self);
+int QAbstractItemView_verticalOffset(const QAbstractItemView* self);
+bool QAbstractItemView_isIndexHidden(const QAbstractItemView* self, QModelIndex* index);
+void QAbstractItemView_setSelection(QAbstractItemView* self, QRect* rect, int command);
+QRegion* QAbstractItemView_visualRegionForSelection(const QAbstractItemView* self, QItemSelection* selection);
+struct miqt_array /* of QModelIndex* */  QAbstractItemView_selectedIndexes(const QAbstractItemView* self);
+bool QAbstractItemView_edit2(QAbstractItemView* self, QModelIndex* index, int trigger, QEvent* event);
+int QAbstractItemView_selectionCommand(const QAbstractItemView* self, QModelIndex* index, QEvent* event);
+void QAbstractItemView_startDrag(QAbstractItemView* self, int supportedActions);
+void QAbstractItemView_initViewItemOption(const QAbstractItemView* self, QStyleOptionViewItem* option);
+bool QAbstractItemView_focusNextPrevChild(QAbstractItemView* self, bool next);
+bool QAbstractItemView_event(QAbstractItemView* self, QEvent* event);
+bool QAbstractItemView_viewportEvent(QAbstractItemView* self, QEvent* event);
+void QAbstractItemView_mousePressEvent(QAbstractItemView* self, QMouseEvent* event);
+void QAbstractItemView_mouseMoveEvent(QAbstractItemView* self, QMouseEvent* event);
+void QAbstractItemView_mouseReleaseEvent(QAbstractItemView* self, QMouseEvent* event);
+void QAbstractItemView_mouseDoubleClickEvent(QAbstractItemView* self, QMouseEvent* event);
+void QAbstractItemView_dragEnterEvent(QAbstractItemView* self, QDragEnterEvent* event);
+void QAbstractItemView_dragMoveEvent(QAbstractItemView* self, QDragMoveEvent* event);
+void QAbstractItemView_dragLeaveEvent(QAbstractItemView* self, QDragLeaveEvent* event);
+void QAbstractItemView_dropEvent(QAbstractItemView* self, QDropEvent* event);
+void QAbstractItemView_focusInEvent(QAbstractItemView* self, QFocusEvent* event);
+void QAbstractItemView_focusOutEvent(QAbstractItemView* self, QFocusEvent* event);
+void QAbstractItemView_keyPressEvent(QAbstractItemView* self, QKeyEvent* event);
+void QAbstractItemView_resizeEvent(QAbstractItemView* self, QResizeEvent* event);
+void QAbstractItemView_timerEvent(QAbstractItemView* self, QTimerEvent* event);
+void QAbstractItemView_inputMethodEvent(QAbstractItemView* self, QInputMethodEvent* event);
+bool QAbstractItemView_eventFilter(QAbstractItemView* self, QObject* object, QEvent* event);
+QSize* QAbstractItemView_viewportSizeHint(const QAbstractItemView* self);
+struct miqt_string QAbstractItemView_tr2(const char* s, const char* c);
+struct miqt_string QAbstractItemView_tr3(const char* s, const char* c, int n);
+
+bool QAbstractItemView_override_virtual_setModel(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setModel(void* self, QAbstractItemModel* model);
+bool QAbstractItemView_override_virtual_setSelectionModel(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setSelectionModel(void* self, QItemSelectionModel* selectionModel);
+bool QAbstractItemView_override_virtual_keyboardSearch(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_keyboardSearch(void* self, struct miqt_string search);
+bool QAbstractItemView_override_virtual_visualRect(void* self, intptr_t slot);
+QRect* QAbstractItemView_virtualbase_visualRect(const void* self, QModelIndex* index);
+bool QAbstractItemView_override_virtual_scrollTo(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_scrollTo(void* self, QModelIndex* index, int hint);
+bool QAbstractItemView_override_virtual_indexAt(void* self, intptr_t slot);
+QModelIndex* QAbstractItemView_virtualbase_indexAt(const void* self, QPoint* point);
+bool QAbstractItemView_override_virtual_sizeHintForRow(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_sizeHintForRow(const void* self, int row);
+bool QAbstractItemView_override_virtual_sizeHintForColumn(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_sizeHintForColumn(const void* self, int column);
+bool QAbstractItemView_override_virtual_itemDelegateForIndex(void* self, intptr_t slot);
+QAbstractItemDelegate* QAbstractItemView_virtualbase_itemDelegateForIndex(const void* self, QModelIndex* index);
+bool QAbstractItemView_override_virtual_inputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractItemView_virtualbase_inputMethodQuery(const void* self, int query);
+bool QAbstractItemView_override_virtual_reset(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_reset(void* self);
+bool QAbstractItemView_override_virtual_setRootIndex(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setRootIndex(void* self, QModelIndex* index);
+bool QAbstractItemView_override_virtual_doItemsLayout(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_doItemsLayout(void* self);
+bool QAbstractItemView_override_virtual_selectAll(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_selectAll(void* self);
+bool QAbstractItemView_override_virtual_dataChanged(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */  roles);
+bool QAbstractItemView_override_virtual_rowsInserted(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_rowsInserted(void* self, QModelIndex* parent, int start, int end);
+bool QAbstractItemView_override_virtual_rowsAboutToBeRemoved(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_rowsAboutToBeRemoved(void* self, QModelIndex* parent, int start, int end);
+bool QAbstractItemView_override_virtual_selectionChanged(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_selectionChanged(void* self, QItemSelection* selected, QItemSelection* deselected);
+bool QAbstractItemView_override_virtual_currentChanged(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_currentChanged(void* self, QModelIndex* current, QModelIndex* previous);
+bool QAbstractItemView_override_virtual_updateEditorData(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_updateEditorData(void* self);
+bool QAbstractItemView_override_virtual_updateEditorGeometries(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_updateEditorGeometries(void* self);
+bool QAbstractItemView_override_virtual_updateGeometries(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_updateGeometries(void* self);
+bool QAbstractItemView_override_virtual_verticalScrollbarAction(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_verticalScrollbarAction(void* self, int action);
+bool QAbstractItemView_override_virtual_horizontalScrollbarAction(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_horizontalScrollbarAction(void* self, int action);
+bool QAbstractItemView_override_virtual_verticalScrollbarValueChanged(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_verticalScrollbarValueChanged(void* self, int value);
+bool QAbstractItemView_override_virtual_horizontalScrollbarValueChanged(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_horizontalScrollbarValueChanged(void* self, int value);
+bool QAbstractItemView_override_virtual_closeEditor(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_closeEditor(void* self, QWidget* editor, int hint);
+bool QAbstractItemView_override_virtual_commitData(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_commitData(void* self, QWidget* editor);
+bool QAbstractItemView_override_virtual_editorDestroyed(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_editorDestroyed(void* self, QObject* editor);
+bool QAbstractItemView_override_virtual_moveCursor(void* self, intptr_t slot);
+QModelIndex* QAbstractItemView_virtualbase_moveCursor(void* self, int cursorAction, int modifiers);
+bool QAbstractItemView_override_virtual_horizontalOffset(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_horizontalOffset(const void* self);
+bool QAbstractItemView_override_virtual_verticalOffset(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_verticalOffset(const void* self);
+bool QAbstractItemView_override_virtual_isIndexHidden(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_isIndexHidden(const void* self, QModelIndex* index);
+bool QAbstractItemView_override_virtual_setSelection(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setSelection(void* self, QRect* rect, int command);
+bool QAbstractItemView_override_virtual_visualRegionForSelection(void* self, intptr_t slot);
+QRegion* QAbstractItemView_virtualbase_visualRegionForSelection(const void* self, QItemSelection* selection);
+bool QAbstractItemView_override_virtual_selectedIndexes(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractItemView_virtualbase_selectedIndexes(const void* self);
+bool QAbstractItemView_override_virtual_edit2(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_edit2(void* self, QModelIndex* index, int trigger, QEvent* event);
+bool QAbstractItemView_override_virtual_selectionCommand(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_selectionCommand(const void* self, QModelIndex* index, QEvent* event);
+bool QAbstractItemView_override_virtual_startDrag(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_startDrag(void* self, int supportedActions);
+bool QAbstractItemView_override_virtual_initViewItemOption(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_initViewItemOption(const void* self, QStyleOptionViewItem* option);
+bool QAbstractItemView_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_focusNextPrevChild(void* self, bool next);
+bool QAbstractItemView_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_event(void* self, QEvent* event);
+bool QAbstractItemView_override_virtual_viewportEvent(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_viewportEvent(void* self, QEvent* event);
+bool QAbstractItemView_override_virtual_mousePressEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
+bool QAbstractItemView_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
+bool QAbstractItemView_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
+bool QAbstractItemView_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
+bool QAbstractItemView_override_virtual_dragEnterEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
+bool QAbstractItemView_override_virtual_dragMoveEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
+bool QAbstractItemView_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
+bool QAbstractItemView_override_virtual_dropEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_dropEvent(void* self, QDropEvent* event);
+bool QAbstractItemView_override_virtual_focusInEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_focusInEvent(void* self, QFocusEvent* event);
+bool QAbstractItemView_override_virtual_focusOutEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
+bool QAbstractItemView_override_virtual_keyPressEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
+bool QAbstractItemView_override_virtual_resizeEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_resizeEvent(void* self, QResizeEvent* event);
+bool QAbstractItemView_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractItemView_override_virtual_inputMethodEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
+bool QAbstractItemView_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_eventFilter(void* self, QObject* object, QEvent* event);
+bool QAbstractItemView_override_virtual_viewportSizeHint(void* self, intptr_t slot);
+QSize* QAbstractItemView_virtualbase_viewportSizeHint(const void* self);
+bool QAbstractItemView_override_virtual_minimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractItemView_virtualbase_minimumSizeHint(const void* self);
+bool QAbstractItemView_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractItemView_virtualbase_sizeHint(const void* self);
+bool QAbstractItemView_override_virtual_setupViewport(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setupViewport(void* self, QWidget* viewport);
+bool QAbstractItemView_override_virtual_paintEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_paintEvent(void* self, QPaintEvent* param1);
+bool QAbstractItemView_override_virtual_wheelEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_wheelEvent(void* self, QWheelEvent* param1);
+bool QAbstractItemView_override_virtual_contextMenuEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1);
+bool QAbstractItemView_override_virtual_scrollContentsBy(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_scrollContentsBy(void* self, int dx, int dy);
+bool QAbstractItemView_override_virtual_changeEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_changeEvent(void* self, QEvent* param1);
+bool QAbstractItemView_override_virtual_initStyleOption(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_initStyleOption(const void* self, QStyleOptionFrame* option);
+bool QAbstractItemView_override_virtual_devType(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_devType(const void* self);
+bool QAbstractItemView_override_virtual_setVisible(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_setVisible(void* self, bool visible);
+bool QAbstractItemView_override_virtual_heightForWidth(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_heightForWidth(const void* self, int param1);
+bool QAbstractItemView_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_hasHeightForWidth(const void* self);
+bool QAbstractItemView_override_virtual_paintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractItemView_virtualbase_paintEngine(const void* self);
+bool QAbstractItemView_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
+bool QAbstractItemView_override_virtual_enterEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_enterEvent(void* self, QEnterEvent* event);
+bool QAbstractItemView_override_virtual_leaveEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_leaveEvent(void* self, QEvent* event);
+bool QAbstractItemView_override_virtual_moveEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_moveEvent(void* self, QMoveEvent* event);
+bool QAbstractItemView_override_virtual_closeEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_closeEvent(void* self, QCloseEvent* event);
+bool QAbstractItemView_override_virtual_tabletEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_tabletEvent(void* self, QTabletEvent* event);
+bool QAbstractItemView_override_virtual_actionEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_actionEvent(void* self, QActionEvent* event);
+bool QAbstractItemView_override_virtual_showEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_showEvent(void* self, QShowEvent* event);
+bool QAbstractItemView_override_virtual_hideEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_hideEvent(void* self, QHideEvent* event);
+bool QAbstractItemView_override_virtual_nativeEvent(void* self, intptr_t slot);
+bool QAbstractItemView_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+bool QAbstractItemView_override_virtual_metric(void* self, intptr_t slot);
+int QAbstractItemView_virtualbase_metric(const void* self, int param1);
+bool QAbstractItemView_override_virtual_initPainter(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_initPainter(const void* self, QPainter* painter);
+bool QAbstractItemView_override_virtual_redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractItemView_virtualbase_redirected(const void* self, QPoint* offset);
+bool QAbstractItemView_override_virtual_sharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractItemView_virtualbase_sharedPainter(const void* self);
+bool QAbstractItemView_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractItemView_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractItemView_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractItemView_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractItemView_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+int QAbstractItemView_protectedbase_state(bool* _dynamic_cast_ok, const void* self);
+void QAbstractItemView_protectedbase_setState(bool* _dynamic_cast_ok, void* self, int state);
+void QAbstractItemView_protectedbase_scheduleDelayedItemsLayout(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_executeDelayedItemsLayout(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_setDirtyRegion(bool* _dynamic_cast_ok, void* self, QRegion* region);
+void QAbstractItemView_protectedbase_scrollDirtyRegion(bool* _dynamic_cast_ok, void* self, int dx, int dy);
+QPoint* QAbstractItemView_protectedbase_dirtyRegionOffset(bool* _dynamic_cast_ok, const void* self);
+void QAbstractItemView_protectedbase_startAutoScroll(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_stopAutoScroll(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_doAutoScroll(bool* _dynamic_cast_ok, void* self);
+int QAbstractItemView_protectedbase_dropIndicatorPosition(bool* _dynamic_cast_ok, const void* self);
+void QAbstractItemView_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom);
+QMargins* QAbstractItemView_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self);
+void QAbstractItemView_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1);
+void QAbstractItemView_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_create(bool* _dynamic_cast_ok, void* self);
+void QAbstractItemView_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
+bool QAbstractItemView_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
+bool QAbstractItemView_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
+QObject* QAbstractItemView_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemView_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractItemView_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractItemView_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractItemView_delete(QAbstractItemView* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractnativeeventfilter.cpp

@@ -0,0 +1,68 @@
+#include <QAbstractNativeEventFilter>
+#include <QByteArray>
+#include <qabstractnativeeventfilter.h>
+#include "gen_qabstractnativeeventfilter.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool miqt_exec_callback_QAbstractNativeEventFilter_nativeEventFilter(QAbstractNativeEventFilter*, intptr_t, struct miqt_string, void*, intptr_t*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAbstractNativeEventFilter final : public QAbstractNativeEventFilter {
+public:
+
+	MiqtVirtualQAbstractNativeEventFilter(): QAbstractNativeEventFilter() {}
+
+	virtual ~MiqtVirtualQAbstractNativeEventFilter() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__nativeEventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool nativeEventFilter(const QByteArray& eventType, void* message, qintptr* result) override {
+		if (handle__nativeEventFilter == 0) {
+			return false; // Pure virtual, there is no base we can call
+		}
+
+		const QByteArray eventType_qb = eventType;
+		struct miqt_string eventType_ms;
+		eventType_ms.len = eventType_qb.length();
+		eventType_ms.data = static_cast<char*>(malloc(eventType_ms.len));
+		memcpy(eventType_ms.data, eventType_qb.data(), eventType_ms.len);
+		struct miqt_string sigval1 = eventType_ms;
+		void* sigval2 = message;
+		qintptr* result_ret = result;
+		intptr_t* sigval3 = (intptr_t*)(result_ret);
+		bool callback_return_value = miqt_exec_callback_QAbstractNativeEventFilter_nativeEventFilter(this, handle__nativeEventFilter, sigval1, sigval2, sigval3);
+		return callback_return_value;
+	}
+
+};
+
+QAbstractNativeEventFilter* QAbstractNativeEventFilter_new() {
+	return new (std::nothrow) MiqtVirtualQAbstractNativeEventFilter();
+}
+
+bool QAbstractNativeEventFilter_nativeEventFilter(QAbstractNativeEventFilter* self, struct miqt_string eventType, void* message, intptr_t* result) {
+	QByteArray eventType_QByteArray(eventType.data, eventType.len);
+	return self->nativeEventFilter(eventType_QByteArray, message, (qintptr*)(result));
+}
+
+bool QAbstractNativeEventFilter_override_virtual_nativeEventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractNativeEventFilter* self_cast = dynamic_cast<MiqtVirtualQAbstractNativeEventFilter*>( (QAbstractNativeEventFilter*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__nativeEventFilter = slot;
+	return true;
+}
+
+void QAbstractNativeEventFilter_delete(QAbstractNativeEventFilter* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qabstractnativeeventfilter.go

@@ -0,0 +1,106 @@
+package qt6
+
+/*
+
+#include "gen_qabstractnativeeventfilter.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAbstractNativeEventFilter struct {
+	h *C.QAbstractNativeEventFilter
+}
+
+func (this *QAbstractNativeEventFilter) cPointer() *C.QAbstractNativeEventFilter {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAbstractNativeEventFilter) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAbstractNativeEventFilter constructs the type using only CGO pointers.
+func newQAbstractNativeEventFilter(h *C.QAbstractNativeEventFilter) *QAbstractNativeEventFilter {
+	if h == nil {
+		return nil
+	}
+
+	return &QAbstractNativeEventFilter{h: h}
+}
+
+// UnsafeNewQAbstractNativeEventFilter constructs the type using only unsafe pointers.
+func UnsafeNewQAbstractNativeEventFilter(h unsafe.Pointer) *QAbstractNativeEventFilter {
+	return newQAbstractNativeEventFilter((*C.QAbstractNativeEventFilter)(h))
+}
+
+// NewQAbstractNativeEventFilter constructs a new QAbstractNativeEventFilter object.
+func NewQAbstractNativeEventFilter() *QAbstractNativeEventFilter {
+
+	return newQAbstractNativeEventFilter(C.QAbstractNativeEventFilter_new())
+}
+
+func (this *QAbstractNativeEventFilter) NativeEventFilter(eventType []byte, message unsafe.Pointer, result *uintptr) bool {
+	eventType_alias := C.struct_miqt_string{}
+	if len(eventType) > 0 {
+		eventType_alias.data = (*C.char)(unsafe.Pointer(&eventType[0]))
+	} else {
+		eventType_alias.data = (*C.char)(unsafe.Pointer(nil))
+	}
+	eventType_alias.len = C.size_t(len(eventType))
+	return (bool)(C.QAbstractNativeEventFilter_nativeEventFilter(this.h, eventType_alias, message, (*C.intptr_t)(unsafe.Pointer(result))))
+}
+func (this *QAbstractNativeEventFilter) OnNativeEventFilter(slot func(eventType []byte, message unsafe.Pointer, result *uintptr) bool) {
+	ok := C.QAbstractNativeEventFilter_override_virtual_nativeEventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAbstractNativeEventFilter_nativeEventFilter
+func miqt_exec_callback_QAbstractNativeEventFilter_nativeEventFilter(self *C.QAbstractNativeEventFilter, cb C.intptr_t, eventType C.struct_miqt_string, message unsafe.Pointer, result *C.intptr_t) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(eventType []byte, message unsafe.Pointer, result *uintptr) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var eventType_bytearray C.struct_miqt_string = eventType
+	eventType_ret := C.GoBytes(unsafe.Pointer(eventType_bytearray.data), C.int(int64(eventType_bytearray.len)))
+	C.free(unsafe.Pointer(eventType_bytearray.data))
+	slotval1 := eventType_ret
+	slotval2 := (unsafe.Pointer)(message)
+
+	slotval3 := (*uintptr)(unsafe.Pointer(result))
+
+	virtualReturn := gofunc(slotval1, slotval2, slotval3)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAbstractNativeEventFilter) Delete() {
+	C.QAbstractNativeEventFilter_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAbstractNativeEventFilter) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAbstractNativeEventFilter) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qabstractnativeeventfilter.h

@@ -0,0 +1,35 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTNATIVEEVENTFILTER_H
+#define MIQT_QT6_GEN_QABSTRACTNATIVEEVENTFILTER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractNativeEventFilter;
+#else
+typedef struct QAbstractNativeEventFilter QAbstractNativeEventFilter;
+#endif
+
+QAbstractNativeEventFilter* QAbstractNativeEventFilter_new();
+bool QAbstractNativeEventFilter_nativeEventFilter(QAbstractNativeEventFilter* self, struct miqt_string eventType, void* message, intptr_t* result);
+
+bool QAbstractNativeEventFilter_override_virtual_nativeEventFilter(void* self, intptr_t slot);
+bool QAbstractNativeEventFilter_virtualbase_nativeEventFilter(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+
+void QAbstractNativeEventFilter_delete(QAbstractNativeEventFilter* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractproxymodel.h

@@ -0,0 +1,223 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTPROXYMODEL_H
+#define MIQT_QT6_GEN_QABSTRACTPROXYMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractProxyModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QItemSelection;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QModelRoleDataSpan;
+class QObject;
+class QSize;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractProxyModel QAbstractProxyModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QItemSelection QItemSelection;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QModelRoleDataSpan QModelRoleDataSpan;
+typedef struct QObject QObject;
+typedef struct QSize QSize;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QAbstractProxyModel* QAbstractProxyModel_new();
+QAbstractProxyModel* QAbstractProxyModel_new2(QObject* parent);
+void QAbstractProxyModel_virtbase(QAbstractProxyModel* src, QAbstractItemModel** outptr_QAbstractItemModel);
+QMetaObject* QAbstractProxyModel_metaObject(const QAbstractProxyModel* self);
+void* QAbstractProxyModel_metacast(QAbstractProxyModel* self, const char* param1);
+struct miqt_string QAbstractProxyModel_tr(const char* s);
+void QAbstractProxyModel_setSourceModel(QAbstractProxyModel* self, QAbstractItemModel* sourceModel);
+QAbstractItemModel* QAbstractProxyModel_sourceModel(const QAbstractProxyModel* self);
+QModelIndex* QAbstractProxyModel_mapToSource(const QAbstractProxyModel* self, QModelIndex* proxyIndex);
+QModelIndex* QAbstractProxyModel_mapFromSource(const QAbstractProxyModel* self, QModelIndex* sourceIndex);
+QItemSelection* QAbstractProxyModel_mapSelectionToSource(const QAbstractProxyModel* self, QItemSelection* selection);
+QItemSelection* QAbstractProxyModel_mapSelectionFromSource(const QAbstractProxyModel* self, QItemSelection* selection);
+bool QAbstractProxyModel_submit(QAbstractProxyModel* self);
+void QAbstractProxyModel_revert(QAbstractProxyModel* self);
+QVariant* QAbstractProxyModel_data(const QAbstractProxyModel* self, QModelIndex* proxyIndex, int role);
+QVariant* QAbstractProxyModel_headerData(const QAbstractProxyModel* self, int section, int orientation, int role);
+struct miqt_map /* of int to QVariant* */  QAbstractProxyModel_itemData(const QAbstractProxyModel* self, QModelIndex* index);
+int QAbstractProxyModel_flags(const QAbstractProxyModel* self, QModelIndex* index);
+bool QAbstractProxyModel_setData(QAbstractProxyModel* self, QModelIndex* index, QVariant* value, int role);
+bool QAbstractProxyModel_setItemData(QAbstractProxyModel* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractProxyModel_setHeaderData(QAbstractProxyModel* self, int section, int orientation, QVariant* value, int role);
+bool QAbstractProxyModel_clearItemData(QAbstractProxyModel* self, QModelIndex* index);
+QModelIndex* QAbstractProxyModel_buddy(const QAbstractProxyModel* self, QModelIndex* index);
+bool QAbstractProxyModel_canFetchMore(const QAbstractProxyModel* self, QModelIndex* parent);
+void QAbstractProxyModel_fetchMore(QAbstractProxyModel* self, QModelIndex* parent);
+void QAbstractProxyModel_sort(QAbstractProxyModel* self, int column, int order);
+QSize* QAbstractProxyModel_span(const QAbstractProxyModel* self, QModelIndex* index);
+bool QAbstractProxyModel_hasChildren(const QAbstractProxyModel* self, QModelIndex* parent);
+QModelIndex* QAbstractProxyModel_sibling(const QAbstractProxyModel* self, int row, int column, QModelIndex* idx);
+QMimeData* QAbstractProxyModel_mimeData(const QAbstractProxyModel* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractProxyModel_canDropMimeData(const QAbstractProxyModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractProxyModel_dropMimeData(QAbstractProxyModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+struct miqt_array /* of struct miqt_string */  QAbstractProxyModel_mimeTypes(const QAbstractProxyModel* self);
+int QAbstractProxyModel_supportedDragActions(const QAbstractProxyModel* self);
+int QAbstractProxyModel_supportedDropActions(const QAbstractProxyModel* self);
+struct miqt_map /* of int to struct miqt_string */  QAbstractProxyModel_roleNames(const QAbstractProxyModel* self);
+struct miqt_string QAbstractProxyModel_tr2(const char* s, const char* c);
+struct miqt_string QAbstractProxyModel_tr3(const char* s, const char* c, int n);
+
+bool QAbstractProxyModel_override_virtual_setSourceModel(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_setSourceModel(void* self, QAbstractItemModel* sourceModel);
+bool QAbstractProxyModel_override_virtual_mapToSource(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_mapToSource(const void* self, QModelIndex* proxyIndex);
+bool QAbstractProxyModel_override_virtual_mapFromSource(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_mapFromSource(const void* self, QModelIndex* sourceIndex);
+bool QAbstractProxyModel_override_virtual_mapSelectionToSource(void* self, intptr_t slot);
+QItemSelection* QAbstractProxyModel_virtualbase_mapSelectionToSource(const void* self, QItemSelection* selection);
+bool QAbstractProxyModel_override_virtual_mapSelectionFromSource(void* self, intptr_t slot);
+QItemSelection* QAbstractProxyModel_virtualbase_mapSelectionFromSource(const void* self, QItemSelection* selection);
+bool QAbstractProxyModel_override_virtual_submit(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_submit(void* self);
+bool QAbstractProxyModel_override_virtual_revert(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_revert(void* self);
+bool QAbstractProxyModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QAbstractProxyModel_virtualbase_data(const void* self, QModelIndex* proxyIndex, int role);
+bool QAbstractProxyModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QAbstractProxyModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QAbstractProxyModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QAbstractProxyModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QAbstractProxyModel_override_virtual_flags(void* self, intptr_t slot);
+int QAbstractProxyModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QAbstractProxyModel_override_virtual_setData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QAbstractProxyModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QAbstractProxyModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QAbstractProxyModel_override_virtual_clearItemData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_clearItemData(void* self, QModelIndex* index);
+bool QAbstractProxyModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QAbstractProxyModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_sort(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_sort(void* self, int column, int order);
+bool QAbstractProxyModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QAbstractProxyModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QAbstractProxyModel_override_virtual_hasChildren(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_hasChildren(const void* self, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QAbstractProxyModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QAbstractProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QAbstractProxyModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QAbstractProxyModel_virtualbase_mimeTypes(const void* self);
+bool QAbstractProxyModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QAbstractProxyModel_virtualbase_supportedDragActions(const void* self);
+bool QAbstractProxyModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QAbstractProxyModel_virtualbase_supportedDropActions(const void* self);
+bool QAbstractProxyModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QAbstractProxyModel_virtualbase_roleNames(const void* self);
+bool QAbstractProxyModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_parent(void* self, intptr_t slot);
+QModelIndex* QAbstractProxyModel_virtualbase_parent(const void* self, QModelIndex* child);
+bool QAbstractProxyModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QAbstractProxyModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QAbstractProxyModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QAbstractProxyModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractProxyModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QAbstractProxyModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QAbstractProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QAbstractProxyModel_override_virtual_multiData(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+bool QAbstractProxyModel_override_virtual_resetInternalData(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_resetInternalData(void* self);
+bool QAbstractProxyModel_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_event(void* self, QEvent* event);
+bool QAbstractProxyModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractProxyModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractProxyModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractProxyModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractProxyModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractProxyModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractProxyModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractProxyModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QModelIndex* QAbstractProxyModel_protectedbase_createSourceIndex(bool* _dynamic_cast_ok, const void* self, int row, int col, void* internalPtr);
+QModelIndex* QAbstractProxyModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QAbstractProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QAbstractProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+void QAbstractProxyModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractProxyModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractProxyModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+bool QAbstractProxyModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QAbstractProxyModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractProxyModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QAbstractProxyModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+bool QAbstractProxyModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QAbstractProxyModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QAbstractProxyModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QAbstractProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QAbstractProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QAbstractProxyModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractProxyModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractProxyModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractProxyModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractProxyModel_connect_sourceModelChanged(QAbstractProxyModel* self, intptr_t slot);
+
+void QAbstractProxyModel_delete(QAbstractProxyModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractscrollarea.h

@@ -0,0 +1,267 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTSCROLLAREA_H
+#define MIQT_QT6_GEN_QABSTRACTSCROLLAREA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractScrollArea;
+class QActionEvent;
+class QChildEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
+class QEnterEvent;
+class QEvent;
+class QFocusEvent;
+class QFrame;
+class QHideEvent;
+class QInputMethodEvent;
+class QKeyEvent;
+class QMargins;
+class QMetaMethod;
+class QMetaObject;
+class QMouseEvent;
+class QMoveEvent;
+class QObject;
+class QPaintDevice;
+class QPaintEngine;
+class QPaintEvent;
+class QPainter;
+class QPoint;
+class QResizeEvent;
+class QScrollBar;
+class QShowEvent;
+class QSize;
+class QStyleOptionFrame;
+class QTabletEvent;
+class QTimerEvent;
+class QVariant;
+class QWheelEvent;
+class QWidget;
+#else
+typedef struct QAbstractScrollArea QAbstractScrollArea;
+typedef struct QActionEvent QActionEvent;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
+typedef struct QEnterEvent QEnterEvent;
+typedef struct QEvent QEvent;
+typedef struct QFocusEvent QFocusEvent;
+typedef struct QFrame QFrame;
+typedef struct QHideEvent QHideEvent;
+typedef struct QInputMethodEvent QInputMethodEvent;
+typedef struct QKeyEvent QKeyEvent;
+typedef struct QMargins QMargins;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
+typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
+typedef struct QPoint QPoint;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QScrollBar QScrollBar;
+typedef struct QShowEvent QShowEvent;
+typedef struct QSize QSize;
+typedef struct QStyleOptionFrame QStyleOptionFrame;
+typedef struct QTabletEvent QTabletEvent;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractScrollArea* QAbstractScrollArea_new(QWidget* parent);
+QAbstractScrollArea* QAbstractScrollArea_new2();
+void QAbstractScrollArea_virtbase(QAbstractScrollArea* src, QFrame** outptr_QFrame);
+QMetaObject* QAbstractScrollArea_metaObject(const QAbstractScrollArea* self);
+void* QAbstractScrollArea_metacast(QAbstractScrollArea* self, const char* param1);
+struct miqt_string QAbstractScrollArea_tr(const char* s);
+int QAbstractScrollArea_verticalScrollBarPolicy(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setVerticalScrollBarPolicy(QAbstractScrollArea* self, int verticalScrollBarPolicy);
+QScrollBar* QAbstractScrollArea_verticalScrollBar(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setVerticalScrollBar(QAbstractScrollArea* self, QScrollBar* scrollbar);
+int QAbstractScrollArea_horizontalScrollBarPolicy(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setHorizontalScrollBarPolicy(QAbstractScrollArea* self, int horizontalScrollBarPolicy);
+QScrollBar* QAbstractScrollArea_horizontalScrollBar(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setHorizontalScrollBar(QAbstractScrollArea* self, QScrollBar* scrollbar);
+QWidget* QAbstractScrollArea_cornerWidget(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setCornerWidget(QAbstractScrollArea* self, QWidget* widget);
+void QAbstractScrollArea_addScrollBarWidget(QAbstractScrollArea* self, QWidget* widget, int alignment);
+struct miqt_array /* of QWidget* */  QAbstractScrollArea_scrollBarWidgets(QAbstractScrollArea* self, int alignment);
+QWidget* QAbstractScrollArea_viewport(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setViewport(QAbstractScrollArea* self, QWidget* widget);
+QSize* QAbstractScrollArea_maximumViewportSize(const QAbstractScrollArea* self);
+QSize* QAbstractScrollArea_minimumSizeHint(const QAbstractScrollArea* self);
+QSize* QAbstractScrollArea_sizeHint(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setupViewport(QAbstractScrollArea* self, QWidget* viewport);
+int QAbstractScrollArea_sizeAdjustPolicy(const QAbstractScrollArea* self);
+void QAbstractScrollArea_setSizeAdjustPolicy(QAbstractScrollArea* self, int policy);
+bool QAbstractScrollArea_eventFilter(QAbstractScrollArea* self, QObject* param1, QEvent* param2);
+bool QAbstractScrollArea_event(QAbstractScrollArea* self, QEvent* param1);
+bool QAbstractScrollArea_viewportEvent(QAbstractScrollArea* self, QEvent* param1);
+void QAbstractScrollArea_resizeEvent(QAbstractScrollArea* self, QResizeEvent* param1);
+void QAbstractScrollArea_paintEvent(QAbstractScrollArea* self, QPaintEvent* param1);
+void QAbstractScrollArea_mousePressEvent(QAbstractScrollArea* self, QMouseEvent* param1);
+void QAbstractScrollArea_mouseReleaseEvent(QAbstractScrollArea* self, QMouseEvent* param1);
+void QAbstractScrollArea_mouseDoubleClickEvent(QAbstractScrollArea* self, QMouseEvent* param1);
+void QAbstractScrollArea_mouseMoveEvent(QAbstractScrollArea* self, QMouseEvent* param1);
+void QAbstractScrollArea_wheelEvent(QAbstractScrollArea* self, QWheelEvent* param1);
+void QAbstractScrollArea_contextMenuEvent(QAbstractScrollArea* self, QContextMenuEvent* param1);
+void QAbstractScrollArea_dragEnterEvent(QAbstractScrollArea* self, QDragEnterEvent* param1);
+void QAbstractScrollArea_dragMoveEvent(QAbstractScrollArea* self, QDragMoveEvent* param1);
+void QAbstractScrollArea_dragLeaveEvent(QAbstractScrollArea* self, QDragLeaveEvent* param1);
+void QAbstractScrollArea_dropEvent(QAbstractScrollArea* self, QDropEvent* param1);
+void QAbstractScrollArea_keyPressEvent(QAbstractScrollArea* self, QKeyEvent* param1);
+void QAbstractScrollArea_scrollContentsBy(QAbstractScrollArea* self, int dx, int dy);
+QSize* QAbstractScrollArea_viewportSizeHint(const QAbstractScrollArea* self);
+struct miqt_string QAbstractScrollArea_tr2(const char* s, const char* c);
+struct miqt_string QAbstractScrollArea_tr3(const char* s, const char* c, int n);
+
+bool QAbstractScrollArea_override_virtual_minimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractScrollArea_virtualbase_minimumSizeHint(const void* self);
+bool QAbstractScrollArea_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractScrollArea_virtualbase_sizeHint(const void* self);
+bool QAbstractScrollArea_override_virtual_setupViewport(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_setupViewport(void* self, QWidget* viewport);
+bool QAbstractScrollArea_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_eventFilter(void* self, QObject* param1, QEvent* param2);
+bool QAbstractScrollArea_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_event(void* self, QEvent* param1);
+bool QAbstractScrollArea_override_virtual_viewportEvent(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_viewportEvent(void* self, QEvent* param1);
+bool QAbstractScrollArea_override_virtual_resizeEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_resizeEvent(void* self, QResizeEvent* param1);
+bool QAbstractScrollArea_override_virtual_paintEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_paintEvent(void* self, QPaintEvent* param1);
+bool QAbstractScrollArea_override_virtual_mousePressEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_mousePressEvent(void* self, QMouseEvent* param1);
+bool QAbstractScrollArea_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* param1);
+bool QAbstractScrollArea_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* param1);
+bool QAbstractScrollArea_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_mouseMoveEvent(void* self, QMouseEvent* param1);
+bool QAbstractScrollArea_override_virtual_wheelEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_wheelEvent(void* self, QWheelEvent* param1);
+bool QAbstractScrollArea_override_virtual_contextMenuEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* param1);
+bool QAbstractScrollArea_override_virtual_dragEnterEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* param1);
+bool QAbstractScrollArea_override_virtual_dragMoveEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* param1);
+bool QAbstractScrollArea_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* param1);
+bool QAbstractScrollArea_override_virtual_dropEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_dropEvent(void* self, QDropEvent* param1);
+bool QAbstractScrollArea_override_virtual_keyPressEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_keyPressEvent(void* self, QKeyEvent* param1);
+bool QAbstractScrollArea_override_virtual_scrollContentsBy(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_scrollContentsBy(void* self, int dx, int dy);
+bool QAbstractScrollArea_override_virtual_viewportSizeHint(void* self, intptr_t slot);
+QSize* QAbstractScrollArea_virtualbase_viewportSizeHint(const void* self);
+bool QAbstractScrollArea_override_virtual_changeEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_changeEvent(void* self, QEvent* param1);
+bool QAbstractScrollArea_override_virtual_initStyleOption(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_initStyleOption(const void* self, QStyleOptionFrame* option);
+bool QAbstractScrollArea_override_virtual_devType(void* self, intptr_t slot);
+int QAbstractScrollArea_virtualbase_devType(const void* self);
+bool QAbstractScrollArea_override_virtual_setVisible(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_setVisible(void* self, bool visible);
+bool QAbstractScrollArea_override_virtual_heightForWidth(void* self, intptr_t slot);
+int QAbstractScrollArea_virtualbase_heightForWidth(const void* self, int param1);
+bool QAbstractScrollArea_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_hasHeightForWidth(const void* self);
+bool QAbstractScrollArea_override_virtual_paintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractScrollArea_virtualbase_paintEngine(const void* self);
+bool QAbstractScrollArea_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
+bool QAbstractScrollArea_override_virtual_focusInEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_focusInEvent(void* self, QFocusEvent* event);
+bool QAbstractScrollArea_override_virtual_focusOutEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
+bool QAbstractScrollArea_override_virtual_enterEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_enterEvent(void* self, QEnterEvent* event);
+bool QAbstractScrollArea_override_virtual_leaveEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_leaveEvent(void* self, QEvent* event);
+bool QAbstractScrollArea_override_virtual_moveEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_moveEvent(void* self, QMoveEvent* event);
+bool QAbstractScrollArea_override_virtual_closeEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_closeEvent(void* self, QCloseEvent* event);
+bool QAbstractScrollArea_override_virtual_tabletEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_tabletEvent(void* self, QTabletEvent* event);
+bool QAbstractScrollArea_override_virtual_actionEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_actionEvent(void* self, QActionEvent* event);
+bool QAbstractScrollArea_override_virtual_showEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_showEvent(void* self, QShowEvent* event);
+bool QAbstractScrollArea_override_virtual_hideEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_hideEvent(void* self, QHideEvent* event);
+bool QAbstractScrollArea_override_virtual_nativeEvent(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+bool QAbstractScrollArea_override_virtual_metric(void* self, intptr_t slot);
+int QAbstractScrollArea_virtualbase_metric(const void* self, int param1);
+bool QAbstractScrollArea_override_virtual_initPainter(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_initPainter(const void* self, QPainter* painter);
+bool QAbstractScrollArea_override_virtual_redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractScrollArea_virtualbase_redirected(const void* self, QPoint* offset);
+bool QAbstractScrollArea_override_virtual_sharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractScrollArea_virtualbase_sharedPainter(const void* self);
+bool QAbstractScrollArea_override_virtual_inputMethodEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1);
+bool QAbstractScrollArea_override_virtual_inputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractScrollArea_virtualbase_inputMethodQuery(const void* self, int param1);
+bool QAbstractScrollArea_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractScrollArea_virtualbase_focusNextPrevChild(void* self, bool next);
+bool QAbstractScrollArea_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractScrollArea_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractScrollArea_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractScrollArea_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractScrollArea_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractScrollArea_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QAbstractScrollArea_protectedbase_setViewportMargins(bool* _dynamic_cast_ok, void* self, int left, int top, int right, int bottom);
+void QAbstractScrollArea_protectedbase_setViewportMarginsWithMargins(bool* _dynamic_cast_ok, void* self, QMargins* margins);
+QMargins* QAbstractScrollArea_protectedbase_viewportMargins(bool* _dynamic_cast_ok, const void* self);
+void QAbstractScrollArea_protectedbase_drawFrame(bool* _dynamic_cast_ok, void* self, QPainter* param1);
+void QAbstractScrollArea_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
+void QAbstractScrollArea_protectedbase_create(bool* _dynamic_cast_ok, void* self);
+void QAbstractScrollArea_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
+bool QAbstractScrollArea_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
+bool QAbstractScrollArea_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
+QObject* QAbstractScrollArea_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractScrollArea_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractScrollArea_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractScrollArea_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractScrollArea_delete(QAbstractScrollArea* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractslider.h

@@ -0,0 +1,255 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTSLIDER_H
+#define MIQT_QT6_GEN_QABSTRACTSLIDER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractSlider;
+class QActionEvent;
+class QChildEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
+class QEnterEvent;
+class QEvent;
+class QFocusEvent;
+class QHideEvent;
+class QInputMethodEvent;
+class QKeyEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMouseEvent;
+class QMoveEvent;
+class QObject;
+class QPaintDevice;
+class QPaintEngine;
+class QPaintEvent;
+class QPainter;
+class QPoint;
+class QResizeEvent;
+class QShowEvent;
+class QSize;
+class QTabletEvent;
+class QTimerEvent;
+class QVariant;
+class QWheelEvent;
+class QWidget;
+#else
+typedef struct QAbstractSlider QAbstractSlider;
+typedef struct QActionEvent QActionEvent;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
+typedef struct QEnterEvent QEnterEvent;
+typedef struct QEvent QEvent;
+typedef struct QFocusEvent QFocusEvent;
+typedef struct QHideEvent QHideEvent;
+typedef struct QInputMethodEvent QInputMethodEvent;
+typedef struct QKeyEvent QKeyEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
+typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
+typedef struct QPoint QPoint;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QShowEvent QShowEvent;
+typedef struct QSize QSize;
+typedef struct QTabletEvent QTabletEvent;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractSlider* QAbstractSlider_new(QWidget* parent);
+QAbstractSlider* QAbstractSlider_new2();
+void QAbstractSlider_virtbase(QAbstractSlider* src, QWidget** outptr_QWidget);
+QMetaObject* QAbstractSlider_metaObject(const QAbstractSlider* self);
+void* QAbstractSlider_metacast(QAbstractSlider* self, const char* param1);
+struct miqt_string QAbstractSlider_tr(const char* s);
+int QAbstractSlider_orientation(const QAbstractSlider* self);
+void QAbstractSlider_setMinimum(QAbstractSlider* self, int minimum);
+int QAbstractSlider_minimum(const QAbstractSlider* self);
+void QAbstractSlider_setMaximum(QAbstractSlider* self, int maximum);
+int QAbstractSlider_maximum(const QAbstractSlider* self);
+void QAbstractSlider_setSingleStep(QAbstractSlider* self, int singleStep);
+int QAbstractSlider_singleStep(const QAbstractSlider* self);
+void QAbstractSlider_setPageStep(QAbstractSlider* self, int pageStep);
+int QAbstractSlider_pageStep(const QAbstractSlider* self);
+void QAbstractSlider_setTracking(QAbstractSlider* self, bool enable);
+bool QAbstractSlider_hasTracking(const QAbstractSlider* self);
+void QAbstractSlider_setSliderDown(QAbstractSlider* self, bool sliderDown);
+bool QAbstractSlider_isSliderDown(const QAbstractSlider* self);
+void QAbstractSlider_setSliderPosition(QAbstractSlider* self, int sliderPosition);
+int QAbstractSlider_sliderPosition(const QAbstractSlider* self);
+void QAbstractSlider_setInvertedAppearance(QAbstractSlider* self, bool invertedAppearance);
+bool QAbstractSlider_invertedAppearance(const QAbstractSlider* self);
+void QAbstractSlider_setInvertedControls(QAbstractSlider* self, bool invertedControls);
+bool QAbstractSlider_invertedControls(const QAbstractSlider* self);
+int QAbstractSlider_value(const QAbstractSlider* self);
+void QAbstractSlider_triggerAction(QAbstractSlider* self, int action);
+void QAbstractSlider_setValue(QAbstractSlider* self, int value);
+void QAbstractSlider_setOrientation(QAbstractSlider* self, int orientation);
+void QAbstractSlider_setRange(QAbstractSlider* self, int min, int max);
+void QAbstractSlider_valueChanged(QAbstractSlider* self, int value);
+void QAbstractSlider_connect_valueChanged(QAbstractSlider* self, intptr_t slot);
+void QAbstractSlider_sliderPressed(QAbstractSlider* self);
+void QAbstractSlider_connect_sliderPressed(QAbstractSlider* self, intptr_t slot);
+void QAbstractSlider_sliderMoved(QAbstractSlider* self, int position);
+void QAbstractSlider_connect_sliderMoved(QAbstractSlider* self, intptr_t slot);
+void QAbstractSlider_sliderReleased(QAbstractSlider* self);
+void QAbstractSlider_connect_sliderReleased(QAbstractSlider* self, intptr_t slot);
+void QAbstractSlider_rangeChanged(QAbstractSlider* self, int min, int max);
+void QAbstractSlider_connect_rangeChanged(QAbstractSlider* self, intptr_t slot);
+void QAbstractSlider_actionTriggered(QAbstractSlider* self, int action);
+void QAbstractSlider_connect_actionTriggered(QAbstractSlider* self, intptr_t slot);
+bool QAbstractSlider_event(QAbstractSlider* self, QEvent* e);
+void QAbstractSlider_sliderChange(QAbstractSlider* self, int change);
+void QAbstractSlider_keyPressEvent(QAbstractSlider* self, QKeyEvent* ev);
+void QAbstractSlider_timerEvent(QAbstractSlider* self, QTimerEvent* param1);
+void QAbstractSlider_wheelEvent(QAbstractSlider* self, QWheelEvent* e);
+void QAbstractSlider_changeEvent(QAbstractSlider* self, QEvent* e);
+struct miqt_string QAbstractSlider_tr2(const char* s, const char* c);
+struct miqt_string QAbstractSlider_tr3(const char* s, const char* c, int n);
+
+bool QAbstractSlider_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractSlider_virtualbase_event(void* self, QEvent* e);
+bool QAbstractSlider_override_virtual_sliderChange(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_sliderChange(void* self, int change);
+bool QAbstractSlider_override_virtual_keyPressEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_keyPressEvent(void* self, QKeyEvent* ev);
+bool QAbstractSlider_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_timerEvent(void* self, QTimerEvent* param1);
+bool QAbstractSlider_override_virtual_wheelEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_wheelEvent(void* self, QWheelEvent* e);
+bool QAbstractSlider_override_virtual_changeEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_changeEvent(void* self, QEvent* e);
+bool QAbstractSlider_override_virtual_devType(void* self, intptr_t slot);
+int QAbstractSlider_virtualbase_devType(const void* self);
+bool QAbstractSlider_override_virtual_setVisible(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_setVisible(void* self, bool visible);
+bool QAbstractSlider_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractSlider_virtualbase_sizeHint(const void* self);
+bool QAbstractSlider_override_virtual_minimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractSlider_virtualbase_minimumSizeHint(const void* self);
+bool QAbstractSlider_override_virtual_heightForWidth(void* self, intptr_t slot);
+int QAbstractSlider_virtualbase_heightForWidth(const void* self, int param1);
+bool QAbstractSlider_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractSlider_virtualbase_hasHeightForWidth(const void* self);
+bool QAbstractSlider_override_virtual_paintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractSlider_virtualbase_paintEngine(const void* self);
+bool QAbstractSlider_override_virtual_mousePressEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
+bool QAbstractSlider_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
+bool QAbstractSlider_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
+bool QAbstractSlider_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
+bool QAbstractSlider_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
+bool QAbstractSlider_override_virtual_focusInEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_focusInEvent(void* self, QFocusEvent* event);
+bool QAbstractSlider_override_virtual_focusOutEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
+bool QAbstractSlider_override_virtual_enterEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_enterEvent(void* self, QEnterEvent* event);
+bool QAbstractSlider_override_virtual_leaveEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_leaveEvent(void* self, QEvent* event);
+bool QAbstractSlider_override_virtual_paintEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_paintEvent(void* self, QPaintEvent* event);
+bool QAbstractSlider_override_virtual_moveEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_moveEvent(void* self, QMoveEvent* event);
+bool QAbstractSlider_override_virtual_resizeEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_resizeEvent(void* self, QResizeEvent* event);
+bool QAbstractSlider_override_virtual_closeEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_closeEvent(void* self, QCloseEvent* event);
+bool QAbstractSlider_override_virtual_contextMenuEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
+bool QAbstractSlider_override_virtual_tabletEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_tabletEvent(void* self, QTabletEvent* event);
+bool QAbstractSlider_override_virtual_actionEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_actionEvent(void* self, QActionEvent* event);
+bool QAbstractSlider_override_virtual_dragEnterEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
+bool QAbstractSlider_override_virtual_dragMoveEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
+bool QAbstractSlider_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
+bool QAbstractSlider_override_virtual_dropEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_dropEvent(void* self, QDropEvent* event);
+bool QAbstractSlider_override_virtual_showEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_showEvent(void* self, QShowEvent* event);
+bool QAbstractSlider_override_virtual_hideEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_hideEvent(void* self, QHideEvent* event);
+bool QAbstractSlider_override_virtual_nativeEvent(void* self, intptr_t slot);
+bool QAbstractSlider_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+bool QAbstractSlider_override_virtual_metric(void* self, intptr_t slot);
+int QAbstractSlider_virtualbase_metric(const void* self, int param1);
+bool QAbstractSlider_override_virtual_initPainter(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_initPainter(const void* self, QPainter* painter);
+bool QAbstractSlider_override_virtual_redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractSlider_virtualbase_redirected(const void* self, QPoint* offset);
+bool QAbstractSlider_override_virtual_sharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractSlider_virtualbase_sharedPainter(const void* self);
+bool QAbstractSlider_override_virtual_inputMethodEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1);
+bool QAbstractSlider_override_virtual_inputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractSlider_virtualbase_inputMethodQuery(const void* self, int param1);
+bool QAbstractSlider_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractSlider_virtualbase_focusNextPrevChild(void* self, bool next);
+bool QAbstractSlider_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractSlider_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractSlider_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractSlider_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractSlider_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractSlider_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractSlider_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QAbstractSlider_protectedbase_setRepeatAction(bool* _dynamic_cast_ok, void* self, int action);
+int QAbstractSlider_protectedbase_repeatAction(bool* _dynamic_cast_ok, const void* self);
+void QAbstractSlider_protectedbase_setRepeatAction2(bool* _dynamic_cast_ok, void* self, int action, int thresholdTime);
+void QAbstractSlider_protectedbase_setRepeatAction3(bool* _dynamic_cast_ok, void* self, int action, int thresholdTime, int repeatTime);
+void QAbstractSlider_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
+void QAbstractSlider_protectedbase_create(bool* _dynamic_cast_ok, void* self);
+void QAbstractSlider_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
+bool QAbstractSlider_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
+bool QAbstractSlider_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
+QObject* QAbstractSlider_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractSlider_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractSlider_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractSlider_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractSlider_delete(QAbstractSlider* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstractspinbox.h

@@ -0,0 +1,279 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTSPINBOX_H
+#define MIQT_QT6_GEN_QABSTRACTSPINBOX_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractSpinBox;
+class QActionEvent;
+class QChildEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDragMoveEvent;
+class QDropEvent;
+class QEnterEvent;
+class QEvent;
+class QFocusEvent;
+class QHideEvent;
+class QInputMethodEvent;
+class QKeyEvent;
+class QLineEdit;
+class QMetaMethod;
+class QMetaObject;
+class QMouseEvent;
+class QMoveEvent;
+class QObject;
+class QPaintDevice;
+class QPaintEngine;
+class QPaintEvent;
+class QPainter;
+class QPoint;
+class QResizeEvent;
+class QShowEvent;
+class QSize;
+class QStyleOptionSpinBox;
+class QTabletEvent;
+class QTimerEvent;
+class QVariant;
+class QWheelEvent;
+class QWidget;
+#else
+typedef struct QAbstractSpinBox QAbstractSpinBox;
+typedef struct QActionEvent QActionEvent;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCloseEvent QCloseEvent;
+typedef struct QContextMenuEvent QContextMenuEvent;
+typedef struct QDragEnterEvent QDragEnterEvent;
+typedef struct QDragLeaveEvent QDragLeaveEvent;
+typedef struct QDragMoveEvent QDragMoveEvent;
+typedef struct QDropEvent QDropEvent;
+typedef struct QEnterEvent QEnterEvent;
+typedef struct QEvent QEvent;
+typedef struct QFocusEvent QFocusEvent;
+typedef struct QHideEvent QHideEvent;
+typedef struct QInputMethodEvent QInputMethodEvent;
+typedef struct QKeyEvent QKeyEvent;
+typedef struct QLineEdit QLineEdit;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMouseEvent QMouseEvent;
+typedef struct QMoveEvent QMoveEvent;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPaintEngine QPaintEngine;
+typedef struct QPaintEvent QPaintEvent;
+typedef struct QPainter QPainter;
+typedef struct QPoint QPoint;
+typedef struct QResizeEvent QResizeEvent;
+typedef struct QShowEvent QShowEvent;
+typedef struct QSize QSize;
+typedef struct QStyleOptionSpinBox QStyleOptionSpinBox;
+typedef struct QTabletEvent QTabletEvent;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+typedef struct QWheelEvent QWheelEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QAbstractSpinBox* QAbstractSpinBox_new(QWidget* parent);
+QAbstractSpinBox* QAbstractSpinBox_new2();
+void QAbstractSpinBox_virtbase(QAbstractSpinBox* src, QWidget** outptr_QWidget);
+QMetaObject* QAbstractSpinBox_metaObject(const QAbstractSpinBox* self);
+void* QAbstractSpinBox_metacast(QAbstractSpinBox* self, const char* param1);
+struct miqt_string QAbstractSpinBox_tr(const char* s);
+int QAbstractSpinBox_buttonSymbols(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setButtonSymbols(QAbstractSpinBox* self, int bs);
+void QAbstractSpinBox_setCorrectionMode(QAbstractSpinBox* self, int cm);
+int QAbstractSpinBox_correctionMode(const QAbstractSpinBox* self);
+bool QAbstractSpinBox_hasAcceptableInput(const QAbstractSpinBox* self);
+struct miqt_string QAbstractSpinBox_text(const QAbstractSpinBox* self);
+struct miqt_string QAbstractSpinBox_specialValueText(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setSpecialValueText(QAbstractSpinBox* self, struct miqt_string txt);
+bool QAbstractSpinBox_wrapping(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setWrapping(QAbstractSpinBox* self, bool w);
+void QAbstractSpinBox_setReadOnly(QAbstractSpinBox* self, bool r);
+bool QAbstractSpinBox_isReadOnly(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setKeyboardTracking(QAbstractSpinBox* self, bool kt);
+bool QAbstractSpinBox_keyboardTracking(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setAlignment(QAbstractSpinBox* self, int flag);
+int QAbstractSpinBox_alignment(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setFrame(QAbstractSpinBox* self, bool frame);
+bool QAbstractSpinBox_hasFrame(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setAccelerated(QAbstractSpinBox* self, bool on);
+bool QAbstractSpinBox_isAccelerated(const QAbstractSpinBox* self);
+void QAbstractSpinBox_setGroupSeparatorShown(QAbstractSpinBox* self, bool shown);
+bool QAbstractSpinBox_isGroupSeparatorShown(const QAbstractSpinBox* self);
+QSize* QAbstractSpinBox_sizeHint(const QAbstractSpinBox* self);
+QSize* QAbstractSpinBox_minimumSizeHint(const QAbstractSpinBox* self);
+void QAbstractSpinBox_interpretText(QAbstractSpinBox* self);
+bool QAbstractSpinBox_event(QAbstractSpinBox* self, QEvent* event);
+QVariant* QAbstractSpinBox_inputMethodQuery(const QAbstractSpinBox* self, int param1);
+int QAbstractSpinBox_validate(const QAbstractSpinBox* self, struct miqt_string input, int* pos);
+void QAbstractSpinBox_fixup(const QAbstractSpinBox* self, struct miqt_string input);
+void QAbstractSpinBox_stepBy(QAbstractSpinBox* self, int steps);
+void QAbstractSpinBox_stepUp(QAbstractSpinBox* self);
+void QAbstractSpinBox_stepDown(QAbstractSpinBox* self);
+void QAbstractSpinBox_selectAll(QAbstractSpinBox* self);
+void QAbstractSpinBox_clear(QAbstractSpinBox* self);
+void QAbstractSpinBox_resizeEvent(QAbstractSpinBox* self, QResizeEvent* event);
+void QAbstractSpinBox_keyPressEvent(QAbstractSpinBox* self, QKeyEvent* event);
+void QAbstractSpinBox_keyReleaseEvent(QAbstractSpinBox* self, QKeyEvent* event);
+void QAbstractSpinBox_wheelEvent(QAbstractSpinBox* self, QWheelEvent* event);
+void QAbstractSpinBox_focusInEvent(QAbstractSpinBox* self, QFocusEvent* event);
+void QAbstractSpinBox_focusOutEvent(QAbstractSpinBox* self, QFocusEvent* event);
+void QAbstractSpinBox_contextMenuEvent(QAbstractSpinBox* self, QContextMenuEvent* event);
+void QAbstractSpinBox_changeEvent(QAbstractSpinBox* self, QEvent* event);
+void QAbstractSpinBox_closeEvent(QAbstractSpinBox* self, QCloseEvent* event);
+void QAbstractSpinBox_hideEvent(QAbstractSpinBox* self, QHideEvent* event);
+void QAbstractSpinBox_mousePressEvent(QAbstractSpinBox* self, QMouseEvent* event);
+void QAbstractSpinBox_mouseReleaseEvent(QAbstractSpinBox* self, QMouseEvent* event);
+void QAbstractSpinBox_mouseMoveEvent(QAbstractSpinBox* self, QMouseEvent* event);
+void QAbstractSpinBox_timerEvent(QAbstractSpinBox* self, QTimerEvent* event);
+void QAbstractSpinBox_paintEvent(QAbstractSpinBox* self, QPaintEvent* event);
+void QAbstractSpinBox_showEvent(QAbstractSpinBox* self, QShowEvent* event);
+void QAbstractSpinBox_initStyleOption(const QAbstractSpinBox* self, QStyleOptionSpinBox* option);
+int QAbstractSpinBox_stepEnabled(const QAbstractSpinBox* self);
+void QAbstractSpinBox_editingFinished(QAbstractSpinBox* self);
+void QAbstractSpinBox_connect_editingFinished(QAbstractSpinBox* self, intptr_t slot);
+struct miqt_string QAbstractSpinBox_tr2(const char* s, const char* c);
+struct miqt_string QAbstractSpinBox_tr3(const char* s, const char* c, int n);
+
+bool QAbstractSpinBox_override_virtual_sizeHint(void* self, intptr_t slot);
+QSize* QAbstractSpinBox_virtualbase_sizeHint(const void* self);
+bool QAbstractSpinBox_override_virtual_minimumSizeHint(void* self, intptr_t slot);
+QSize* QAbstractSpinBox_virtualbase_minimumSizeHint(const void* self);
+bool QAbstractSpinBox_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractSpinBox_virtualbase_event(void* self, QEvent* event);
+bool QAbstractSpinBox_override_virtual_inputMethodQuery(void* self, intptr_t slot);
+QVariant* QAbstractSpinBox_virtualbase_inputMethodQuery(const void* self, int param1);
+bool QAbstractSpinBox_override_virtual_validate(void* self, intptr_t slot);
+int QAbstractSpinBox_virtualbase_validate(const void* self, struct miqt_string input, int* pos);
+bool QAbstractSpinBox_override_virtual_fixup(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_fixup(const void* self, struct miqt_string input);
+bool QAbstractSpinBox_override_virtual_stepBy(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_stepBy(void* self, int steps);
+bool QAbstractSpinBox_override_virtual_clear(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_clear(void* self);
+bool QAbstractSpinBox_override_virtual_resizeEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_resizeEvent(void* self, QResizeEvent* event);
+bool QAbstractSpinBox_override_virtual_keyPressEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
+bool QAbstractSpinBox_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
+bool QAbstractSpinBox_override_virtual_wheelEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_wheelEvent(void* self, QWheelEvent* event);
+bool QAbstractSpinBox_override_virtual_focusInEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_focusInEvent(void* self, QFocusEvent* event);
+bool QAbstractSpinBox_override_virtual_focusOutEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
+bool QAbstractSpinBox_override_virtual_contextMenuEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
+bool QAbstractSpinBox_override_virtual_changeEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_changeEvent(void* self, QEvent* event);
+bool QAbstractSpinBox_override_virtual_closeEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_closeEvent(void* self, QCloseEvent* event);
+bool QAbstractSpinBox_override_virtual_hideEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_hideEvent(void* self, QHideEvent* event);
+bool QAbstractSpinBox_override_virtual_mousePressEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
+bool QAbstractSpinBox_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
+bool QAbstractSpinBox_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
+bool QAbstractSpinBox_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractSpinBox_override_virtual_paintEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_paintEvent(void* self, QPaintEvent* event);
+bool QAbstractSpinBox_override_virtual_showEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_showEvent(void* self, QShowEvent* event);
+bool QAbstractSpinBox_override_virtual_initStyleOption(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_initStyleOption(const void* self, QStyleOptionSpinBox* option);
+bool QAbstractSpinBox_override_virtual_stepEnabled(void* self, intptr_t slot);
+int QAbstractSpinBox_virtualbase_stepEnabled(const void* self);
+bool QAbstractSpinBox_override_virtual_devType(void* self, intptr_t slot);
+int QAbstractSpinBox_virtualbase_devType(const void* self);
+bool QAbstractSpinBox_override_virtual_setVisible(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_setVisible(void* self, bool visible);
+bool QAbstractSpinBox_override_virtual_heightForWidth(void* self, intptr_t slot);
+int QAbstractSpinBox_virtualbase_heightForWidth(const void* self, int param1);
+bool QAbstractSpinBox_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
+bool QAbstractSpinBox_virtualbase_hasHeightForWidth(const void* self);
+bool QAbstractSpinBox_override_virtual_paintEngine(void* self, intptr_t slot);
+QPaintEngine* QAbstractSpinBox_virtualbase_paintEngine(const void* self);
+bool QAbstractSpinBox_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
+bool QAbstractSpinBox_override_virtual_enterEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_enterEvent(void* self, QEnterEvent* event);
+bool QAbstractSpinBox_override_virtual_leaveEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_leaveEvent(void* self, QEvent* event);
+bool QAbstractSpinBox_override_virtual_moveEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_moveEvent(void* self, QMoveEvent* event);
+bool QAbstractSpinBox_override_virtual_tabletEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_tabletEvent(void* self, QTabletEvent* event);
+bool QAbstractSpinBox_override_virtual_actionEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_actionEvent(void* self, QActionEvent* event);
+bool QAbstractSpinBox_override_virtual_dragEnterEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
+bool QAbstractSpinBox_override_virtual_dragMoveEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
+bool QAbstractSpinBox_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
+bool QAbstractSpinBox_override_virtual_dropEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_dropEvent(void* self, QDropEvent* event);
+bool QAbstractSpinBox_override_virtual_nativeEvent(void* self, intptr_t slot);
+bool QAbstractSpinBox_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, intptr_t* result);
+bool QAbstractSpinBox_override_virtual_metric(void* self, intptr_t slot);
+int QAbstractSpinBox_virtualbase_metric(const void* self, int param1);
+bool QAbstractSpinBox_override_virtual_initPainter(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_initPainter(const void* self, QPainter* painter);
+bool QAbstractSpinBox_override_virtual_redirected(void* self, intptr_t slot);
+QPaintDevice* QAbstractSpinBox_virtualbase_redirected(const void* self, QPoint* offset);
+bool QAbstractSpinBox_override_virtual_sharedPainter(void* self, intptr_t slot);
+QPainter* QAbstractSpinBox_virtualbase_sharedPainter(const void* self);
+bool QAbstractSpinBox_override_virtual_inputMethodEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1);
+bool QAbstractSpinBox_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
+bool QAbstractSpinBox_virtualbase_focusNextPrevChild(void* self, bool next);
+bool QAbstractSpinBox_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractSpinBox_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractSpinBox_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractSpinBox_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractSpinBox_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractSpinBox_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractSpinBox_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QLineEdit* QAbstractSpinBox_protectedbase_lineEdit(bool* _dynamic_cast_ok, const void* self);
+void QAbstractSpinBox_protectedbase_setLineEdit(bool* _dynamic_cast_ok, void* self, QLineEdit* edit);
+void QAbstractSpinBox_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
+void QAbstractSpinBox_protectedbase_create(bool* _dynamic_cast_ok, void* self);
+void QAbstractSpinBox_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
+bool QAbstractSpinBox_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
+bool QAbstractSpinBox_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
+QObject* QAbstractSpinBox_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractSpinBox_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractSpinBox_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractSpinBox_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractSpinBox_delete(QAbstractSpinBox* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qabstracttextdocumentlayout.cpp

@@ -0,0 +1,950 @@
+#include <QAbstractTextDocumentLayout>
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractTextDocumentLayout__PaintContext
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAbstractTextDocumentLayout__Selection
+#include <QChildEvent>
+#include <QEvent>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QPaintDevice>
+#include <QPainter>
+#include <QPalette>
+#include <QPointF>
+#include <QRectF>
+#include <QSizeF>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTextBlock>
+#include <QTextCharFormat>
+#include <QTextCursor>
+#include <QTextDocument>
+#include <QTextFormat>
+#include <QTextFrame>
+#include <QTextInlineObject>
+#include <QTextObjectInterface>
+#include <QTimerEvent>
+#include <qabstracttextdocumentlayout.h>
+#include "gen_qabstracttextdocumentlayout.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QAbstractTextDocumentLayout_update(intptr_t);
+void miqt_exec_callback_QAbstractTextDocumentLayout_updateBlock(intptr_t, QTextBlock*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_documentSizeChanged(intptr_t, QSizeF*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_pageCountChanged(intptr_t, int);
+void miqt_exec_callback_QAbstractTextDocumentLayout_updateWithQRectF(intptr_t, QRectF*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_draw(QAbstractTextDocumentLayout*, intptr_t, QPainter*, QAbstractTextDocumentLayout__PaintContext*);
+int miqt_exec_callback_QAbstractTextDocumentLayout_hitTest(const QAbstractTextDocumentLayout*, intptr_t, QPointF*, int);
+int miqt_exec_callback_QAbstractTextDocumentLayout_pageCount(const QAbstractTextDocumentLayout*, intptr_t);
+QSizeF* miqt_exec_callback_QAbstractTextDocumentLayout_documentSize(const QAbstractTextDocumentLayout*, intptr_t);
+QRectF* miqt_exec_callback_QAbstractTextDocumentLayout_frameBoundingRect(const QAbstractTextDocumentLayout*, intptr_t, QTextFrame*);
+QRectF* miqt_exec_callback_QAbstractTextDocumentLayout_blockBoundingRect(const QAbstractTextDocumentLayout*, intptr_t, QTextBlock*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_documentChanged(QAbstractTextDocumentLayout*, intptr_t, int, int, int);
+void miqt_exec_callback_QAbstractTextDocumentLayout_resizeInlineObject(QAbstractTextDocumentLayout*, intptr_t, QTextInlineObject*, int, QTextFormat*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_positionInlineObject(QAbstractTextDocumentLayout*, intptr_t, QTextInlineObject*, int, QTextFormat*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_drawInlineObject(QAbstractTextDocumentLayout*, intptr_t, QPainter*, QRectF*, QTextInlineObject*, int, QTextFormat*);
+bool miqt_exec_callback_QAbstractTextDocumentLayout_event(QAbstractTextDocumentLayout*, intptr_t, QEvent*);
+bool miqt_exec_callback_QAbstractTextDocumentLayout_eventFilter(QAbstractTextDocumentLayout*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_timerEvent(QAbstractTextDocumentLayout*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_childEvent(QAbstractTextDocumentLayout*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_customEvent(QAbstractTextDocumentLayout*, intptr_t, QEvent*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_connectNotify(QAbstractTextDocumentLayout*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAbstractTextDocumentLayout_disconnectNotify(QAbstractTextDocumentLayout*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAbstractTextDocumentLayout final : public QAbstractTextDocumentLayout {
+public:
+
+	MiqtVirtualQAbstractTextDocumentLayout(QTextDocument* doc): QAbstractTextDocumentLayout(doc) {}
+
+	virtual ~MiqtVirtualQAbstractTextDocumentLayout() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__draw = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void draw(QPainter* painter, const QAbstractTextDocumentLayout::PaintContext& context) override {
+		if (handle__draw == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+
+		QPainter* sigval1 = painter;
+		const QAbstractTextDocumentLayout::PaintContext& context_ret = context;
+		// Cast returned reference into pointer
+		QAbstractTextDocumentLayout__PaintContext* sigval2 = const_cast<QAbstractTextDocumentLayout::PaintContext*>(&context_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_draw(this, handle__draw, sigval1, sigval2);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__hitTest = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual int hitTest(const QPointF& point, Qt::HitTestAccuracy accuracy) const override {
+		if (handle__hitTest == 0) {
+			return 0; // Pure virtual, there is no base we can call
+		}
+
+		const QPointF& point_ret = point;
+		// Cast returned reference into pointer
+		QPointF* sigval1 = const_cast<QPointF*>(&point_ret);
+		Qt::HitTestAccuracy accuracy_ret = accuracy;
+		int sigval2 = static_cast<int>(accuracy_ret);
+		int callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_hitTest(this, handle__hitTest, sigval1, sigval2);
+		return static_cast<int>(callback_return_value);
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__pageCount = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual int pageCount() const override {
+		if (handle__pageCount == 0) {
+			return 0; // Pure virtual, there is no base we can call
+		}
+
+		int callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_pageCount(this, handle__pageCount);
+		return static_cast<int>(callback_return_value);
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__documentSize = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QSizeF documentSize() const override {
+		if (handle__documentSize == 0) {
+			return QSizeF(); // Pure virtual, there is no base we can call
+		}
+
+		QSizeF* callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_documentSize(this, handle__documentSize);
+		return *callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__frameBoundingRect = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QRectF frameBoundingRect(QTextFrame* frame) const override {
+		if (handle__frameBoundingRect == 0) {
+			return QRectF(); // Pure virtual, there is no base we can call
+		}
+
+		QTextFrame* sigval1 = frame;
+		QRectF* callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_frameBoundingRect(this, handle__frameBoundingRect, sigval1);
+		return *callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__blockBoundingRect = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QRectF blockBoundingRect(const QTextBlock& block) const override {
+		if (handle__blockBoundingRect == 0) {
+			return QRectF(); // Pure virtual, there is no base we can call
+		}
+
+		const QTextBlock& block_ret = block;
+		// Cast returned reference into pointer
+		QTextBlock* sigval1 = const_cast<QTextBlock*>(&block_ret);
+		QRectF* callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_blockBoundingRect(this, handle__blockBoundingRect, sigval1);
+		return *callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__documentChanged = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void documentChanged(int from, int charsRemoved, int charsAdded) override {
+		if (handle__documentChanged == 0) {
+			return; // Pure virtual, there is no base we can call
+		}
+
+		int sigval1 = from;
+		int sigval2 = charsRemoved;
+		int sigval3 = charsAdded;
+		miqt_exec_callback_QAbstractTextDocumentLayout_documentChanged(this, handle__documentChanged, sigval1, sigval2, sigval3);
+
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__resizeInlineObject = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void resizeInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat& format) override {
+		if (handle__resizeInlineObject == 0) {
+			QAbstractTextDocumentLayout::resizeInlineObject(item, posInDocument, format);
+			return;
+		}
+
+		QTextInlineObject* sigval1 = new QTextInlineObject(item);
+		int sigval2 = posInDocument;
+		const QTextFormat& format_ret = format;
+		// Cast returned reference into pointer
+		QTextFormat* sigval3 = const_cast<QTextFormat*>(&format_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_resizeInlineObject(this, handle__resizeInlineObject, sigval1, sigval2, sigval3);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_resizeInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__positionInlineObject = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void positionInlineObject(QTextInlineObject item, int posInDocument, const QTextFormat& format) override {
+		if (handle__positionInlineObject == 0) {
+			QAbstractTextDocumentLayout::positionInlineObject(item, posInDocument, format);
+			return;
+		}
+
+		QTextInlineObject* sigval1 = new QTextInlineObject(item);
+		int sigval2 = posInDocument;
+		const QTextFormat& format_ret = format;
+		// Cast returned reference into pointer
+		QTextFormat* sigval3 = const_cast<QTextFormat*>(&format_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_positionInlineObject(this, handle__positionInlineObject, sigval1, sigval2, sigval3);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_positionInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__drawInlineObject = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void drawInlineObject(QPainter* painter, const QRectF& rect, QTextInlineObject object, int posInDocument, const QTextFormat& format) override {
+		if (handle__drawInlineObject == 0) {
+			QAbstractTextDocumentLayout::drawInlineObject(painter, rect, object, posInDocument, format);
+			return;
+		}
+
+		QPainter* sigval1 = painter;
+		const QRectF& rect_ret = rect;
+		// Cast returned reference into pointer
+		QRectF* sigval2 = const_cast<QRectF*>(&rect_ret);
+		QTextInlineObject* sigval3 = new QTextInlineObject(object);
+		int sigval4 = posInDocument;
+		const QTextFormat& format_ret = format;
+		// Cast returned reference into pointer
+		QTextFormat* sigval5 = const_cast<QTextFormat*>(&format_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_drawInlineObject(this, handle__drawInlineObject, sigval1, sigval2, sigval3, sigval4, sigval5);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_drawInlineObject(void* self, QPainter* painter, QRectF* rect, QTextInlineObject* object, int posInDocument, QTextFormat* format);
+
+	// 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 QAbstractTextDocumentLayout::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractTextDocumentLayout_virtualbase_event(void* self, QEvent* 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 QAbstractTextDocumentLayout::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAbstractTextDocumentLayout_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAbstractTextDocumentLayout_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QAbstractTextDocumentLayout::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractTextDocumentLayout_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QAbstractTextDocumentLayout::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractTextDocumentLayout_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QAbstractTextDocumentLayout::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAbstractTextDocumentLayout_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_customEvent(void* self, QEvent* 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) {
+			QAbstractTextDocumentLayout::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QAbstractTextDocumentLayout::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAbstractTextDocumentLayout_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend int QAbstractTextDocumentLayout_protectedbase_formatIndex(bool* _dynamic_cast_ok, void* self, int pos);
+	friend QTextCharFormat* QAbstractTextDocumentLayout_protectedbase_format(bool* _dynamic_cast_ok, void* self, int pos);
+	friend QObject* QAbstractTextDocumentLayout_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAbstractTextDocumentLayout_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAbstractTextDocumentLayout_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAbstractTextDocumentLayout_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAbstractTextDocumentLayout* QAbstractTextDocumentLayout_new(QTextDocument* doc) {
+	return new (std::nothrow) MiqtVirtualQAbstractTextDocumentLayout(doc);
+}
+
+void QAbstractTextDocumentLayout_virtbase(QAbstractTextDocumentLayout* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAbstractTextDocumentLayout_metaObject(const QAbstractTextDocumentLayout* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAbstractTextDocumentLayout_metacast(QAbstractTextDocumentLayout* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAbstractTextDocumentLayout_tr(const char* s) {
+	QString _ret = QAbstractTextDocumentLayout::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAbstractTextDocumentLayout_draw(QAbstractTextDocumentLayout* self, QPainter* painter, QAbstractTextDocumentLayout__PaintContext* context) {
+	self->draw(painter, *context);
+}
+
+int QAbstractTextDocumentLayout_hitTest(const QAbstractTextDocumentLayout* self, QPointF* point, int accuracy) {
+	return self->hitTest(*point, static_cast<Qt::HitTestAccuracy>(accuracy));
+}
+
+struct miqt_string QAbstractTextDocumentLayout_anchorAt(const QAbstractTextDocumentLayout* self, QPointF* pos) {
+	QString _ret = self->anchorAt(*pos);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAbstractTextDocumentLayout_imageAt(const QAbstractTextDocumentLayout* self, QPointF* pos) {
+	QString _ret = self->imageAt(*pos);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QTextFormat* QAbstractTextDocumentLayout_formatAt(const QAbstractTextDocumentLayout* self, QPointF* pos) {
+	return new QTextFormat(self->formatAt(*pos));
+}
+
+QTextBlock* QAbstractTextDocumentLayout_blockWithMarkerAt(const QAbstractTextDocumentLayout* self, QPointF* pos) {
+	return new QTextBlock(self->blockWithMarkerAt(*pos));
+}
+
+int QAbstractTextDocumentLayout_pageCount(const QAbstractTextDocumentLayout* self) {
+	return self->pageCount();
+}
+
+QSizeF* QAbstractTextDocumentLayout_documentSize(const QAbstractTextDocumentLayout* self) {
+	return new QSizeF(self->documentSize());
+}
+
+QRectF* QAbstractTextDocumentLayout_frameBoundingRect(const QAbstractTextDocumentLayout* self, QTextFrame* frame) {
+	return new QRectF(self->frameBoundingRect(frame));
+}
+
+QRectF* QAbstractTextDocumentLayout_blockBoundingRect(const QAbstractTextDocumentLayout* self, QTextBlock* block) {
+	return new QRectF(self->blockBoundingRect(*block));
+}
+
+void QAbstractTextDocumentLayout_setPaintDevice(QAbstractTextDocumentLayout* self, QPaintDevice* device) {
+	self->setPaintDevice(device);
+}
+
+QPaintDevice* QAbstractTextDocumentLayout_paintDevice(const QAbstractTextDocumentLayout* self) {
+	return self->paintDevice();
+}
+
+QTextDocument* QAbstractTextDocumentLayout_document(const QAbstractTextDocumentLayout* self) {
+	return self->document();
+}
+
+void QAbstractTextDocumentLayout_registerHandler(QAbstractTextDocumentLayout* self, int objectType, QObject* component) {
+	self->registerHandler(static_cast<int>(objectType), component);
+}
+
+void QAbstractTextDocumentLayout_unregisterHandler(QAbstractTextDocumentLayout* self, int objectType) {
+	self->unregisterHandler(static_cast<int>(objectType));
+}
+
+QTextObjectInterface* QAbstractTextDocumentLayout_handlerForObject(const QAbstractTextDocumentLayout* self, int objectType) {
+	return self->handlerForObject(static_cast<int>(objectType));
+}
+
+void QAbstractTextDocumentLayout_update(QAbstractTextDocumentLayout* self) {
+	self->update();
+}
+
+void QAbstractTextDocumentLayout_connect_update(QAbstractTextDocumentLayout* self, intptr_t slot) {
+	QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF&)>(&QAbstractTextDocumentLayout::update), self, [=]() {
+		miqt_exec_callback_QAbstractTextDocumentLayout_update(slot);
+	});
+}
+
+void QAbstractTextDocumentLayout_updateBlock(QAbstractTextDocumentLayout* self, QTextBlock* block) {
+	self->updateBlock(*block);
+}
+
+void QAbstractTextDocumentLayout_connect_updateBlock(QAbstractTextDocumentLayout* self, intptr_t slot) {
+	QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(const QTextBlock&)>(&QAbstractTextDocumentLayout::updateBlock), self, [=](const QTextBlock& block) {
+		const QTextBlock& block_ret = block;
+		// Cast returned reference into pointer
+		QTextBlock* sigval1 = const_cast<QTextBlock*>(&block_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_updateBlock(slot, sigval1);
+	});
+}
+
+void QAbstractTextDocumentLayout_documentSizeChanged(QAbstractTextDocumentLayout* self, QSizeF* newSize) {
+	self->documentSizeChanged(*newSize);
+}
+
+void QAbstractTextDocumentLayout_connect_documentSizeChanged(QAbstractTextDocumentLayout* self, intptr_t slot) {
+	QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(const QSizeF&)>(&QAbstractTextDocumentLayout::documentSizeChanged), self, [=](const QSizeF& newSize) {
+		const QSizeF& newSize_ret = newSize;
+		// Cast returned reference into pointer
+		QSizeF* sigval1 = const_cast<QSizeF*>(&newSize_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_documentSizeChanged(slot, sigval1);
+	});
+}
+
+void QAbstractTextDocumentLayout_pageCountChanged(QAbstractTextDocumentLayout* self, int newPages) {
+	self->pageCountChanged(static_cast<int>(newPages));
+}
+
+void QAbstractTextDocumentLayout_connect_pageCountChanged(QAbstractTextDocumentLayout* self, intptr_t slot) {
+	QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(int)>(&QAbstractTextDocumentLayout::pageCountChanged), self, [=](int newPages) {
+		int sigval1 = newPages;
+		miqt_exec_callback_QAbstractTextDocumentLayout_pageCountChanged(slot, sigval1);
+	});
+}
+
+struct miqt_string QAbstractTextDocumentLayout_tr2(const char* s, const char* c) {
+	QString _ret = QAbstractTextDocumentLayout::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAbstractTextDocumentLayout_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAbstractTextDocumentLayout::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAbstractTextDocumentLayout_unregisterHandler2(QAbstractTextDocumentLayout* self, int objectType, QObject* component) {
+	self->unregisterHandler(static_cast<int>(objectType), component);
+}
+
+void QAbstractTextDocumentLayout_updateWithQRectF(QAbstractTextDocumentLayout* self, QRectF* param1) {
+	self->update(*param1);
+}
+
+void QAbstractTextDocumentLayout_connect_updateWithQRectF(QAbstractTextDocumentLayout* self, intptr_t slot) {
+	QAbstractTextDocumentLayout::connect(self, static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF&)>(&QAbstractTextDocumentLayout::update), self, [=](const QRectF& param1) {
+		const QRectF& param1_ret = param1;
+		// Cast returned reference into pointer
+		QRectF* sigval1 = const_cast<QRectF*>(&param1_ret);
+		miqt_exec_callback_QAbstractTextDocumentLayout_updateWithQRectF(slot, sigval1);
+	});
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_draw(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__draw = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_hitTest(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__hitTest = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_pageCount(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__pageCount = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_documentSize(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__documentSize = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_frameBoundingRect(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__frameBoundingRect = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_blockBoundingRect(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__blockBoundingRect = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_documentChanged(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__documentChanged = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_resizeInlineObject(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__resizeInlineObject = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_resizeInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::resizeInlineObject(*item, static_cast<int>(posInDocument), *format);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_positionInlineObject(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__positionInlineObject = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_positionInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::positionInlineObject(*item, static_cast<int>(posInDocument), *format);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_drawInlineObject(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__drawInlineObject = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_drawInlineObject(void* self, QPainter* painter, QRectF* rect, QTextInlineObject* object, int posInDocument, QTextFormat* format) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::drawInlineObject(painter, *rect, *object, static_cast<int>(posInDocument), *format);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::event(event);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAbstractTextDocumentLayout_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::eventFilter(watched, event);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::timerEvent(event);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::childEvent(event);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::customEvent(event);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::connectNotify(*signal);
+}
+
+bool QAbstractTextDocumentLayout_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAbstractTextDocumentLayout_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAbstractTextDocumentLayout*>(self)->QAbstractTextDocumentLayout::disconnectNotify(*signal);
+}
+
+int QAbstractTextDocumentLayout_protectedbase_formatIndex(bool* _dynamic_cast_ok, void* self, int pos) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->formatIndex(static_cast<int>(pos));
+}
+
+QTextCharFormat* QAbstractTextDocumentLayout_protectedbase_format(bool* _dynamic_cast_ok, void* self, int pos) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return new QTextCharFormat(self_cast->format(static_cast<int>(pos)));
+}
+
+QObject* QAbstractTextDocumentLayout_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAbstractTextDocumentLayout_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAbstractTextDocumentLayout_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAbstractTextDocumentLayout_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAbstractTextDocumentLayout* self_cast = dynamic_cast<MiqtVirtualQAbstractTextDocumentLayout*>( (QAbstractTextDocumentLayout*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAbstractTextDocumentLayout_delete(QAbstractTextDocumentLayout* self) {
+	delete self;
+}
+
+QSizeF* QTextObjectInterface_intrinsicSize(QTextObjectInterface* self, QTextDocument* doc, int posInDocument, QTextFormat* format) {
+	return new QSizeF(self->intrinsicSize(doc, static_cast<int>(posInDocument), *format));
+}
+
+void QTextObjectInterface_drawObject(QTextObjectInterface* self, QPainter* painter, QRectF* rect, QTextDocument* doc, int posInDocument, QTextFormat* format) {
+	self->drawObject(painter, *rect, doc, static_cast<int>(posInDocument), *format);
+}
+
+void QTextObjectInterface_operatorAssign(QTextObjectInterface* self, QTextObjectInterface* param1) {
+	self->operator=(*param1);
+}
+
+void QTextObjectInterface_delete(QTextObjectInterface* self) {
+	delete self;
+}
+
+QAbstractTextDocumentLayout__Selection* QAbstractTextDocumentLayout__Selection_new(QAbstractTextDocumentLayout__Selection* param1) {
+	return new (std::nothrow) QAbstractTextDocumentLayout::Selection(*param1);
+}
+
+QTextCursor* QAbstractTextDocumentLayout__Selection_cursor(const QAbstractTextDocumentLayout__Selection* self) {
+	return new QTextCursor(self->cursor);
+}
+
+void QAbstractTextDocumentLayout__Selection_setCursor(QAbstractTextDocumentLayout__Selection* self, QTextCursor* cursor) {
+	self->cursor = *cursor;
+}
+
+QTextCharFormat* QAbstractTextDocumentLayout__Selection_format(const QAbstractTextDocumentLayout__Selection* self) {
+	return new QTextCharFormat(self->format);
+}
+
+void QAbstractTextDocumentLayout__Selection_setFormat(QAbstractTextDocumentLayout__Selection* self, QTextCharFormat* format) {
+	self->format = *format;
+}
+
+void QAbstractTextDocumentLayout__Selection_operatorAssign(QAbstractTextDocumentLayout__Selection* self, QAbstractTextDocumentLayout__Selection* param1) {
+	self->operator=(*param1);
+}
+
+void QAbstractTextDocumentLayout__Selection_delete(QAbstractTextDocumentLayout__Selection* self) {
+	delete self;
+}
+
+QAbstractTextDocumentLayout__PaintContext* QAbstractTextDocumentLayout__PaintContext_new() {
+	return new (std::nothrow) QAbstractTextDocumentLayout::PaintContext();
+}
+
+QAbstractTextDocumentLayout__PaintContext* QAbstractTextDocumentLayout__PaintContext_new2(QAbstractTextDocumentLayout__PaintContext* param1) {
+	return new (std::nothrow) QAbstractTextDocumentLayout::PaintContext(*param1);
+}
+
+int QAbstractTextDocumentLayout__PaintContext_cursorPosition(const QAbstractTextDocumentLayout__PaintContext* self) {
+	return self->cursorPosition;
+}
+
+void QAbstractTextDocumentLayout__PaintContext_setCursorPosition(QAbstractTextDocumentLayout__PaintContext* self, int cursorPosition) {
+	self->cursorPosition = static_cast<int>(cursorPosition);
+}
+
+QPalette* QAbstractTextDocumentLayout__PaintContext_palette(const QAbstractTextDocumentLayout__PaintContext* self) {
+	return new QPalette(self->palette);
+}
+
+void QAbstractTextDocumentLayout__PaintContext_setPalette(QAbstractTextDocumentLayout__PaintContext* self, QPalette* palette) {
+	self->palette = *palette;
+}
+
+QRectF* QAbstractTextDocumentLayout__PaintContext_clip(const QAbstractTextDocumentLayout__PaintContext* self) {
+	return new QRectF(self->clip);
+}
+
+void QAbstractTextDocumentLayout__PaintContext_setClip(QAbstractTextDocumentLayout__PaintContext* self, QRectF* clip) {
+	self->clip = *clip;
+}
+
+struct miqt_array /* of QAbstractTextDocumentLayout__Selection* */  QAbstractTextDocumentLayout__PaintContext_selections(const QAbstractTextDocumentLayout__PaintContext* self) {
+	QList<QAbstractTextDocumentLayout::Selection> selections_ret = self->selections;
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QAbstractTextDocumentLayout__Selection** selections_arr = static_cast<QAbstractTextDocumentLayout__Selection**>(malloc(sizeof(QAbstractTextDocumentLayout__Selection*) * selections_ret.length()));
+	for (size_t i = 0, e = selections_ret.length(); i < e; ++i) {
+		selections_arr[i] = new QAbstractTextDocumentLayout::Selection(selections_ret[i]);
+	}
+	struct miqt_array selections_out;
+	selections_out.len = selections_ret.length();
+	selections_out.data = static_cast<void*>(selections_arr);
+	return selections_out;
+}
+
+void QAbstractTextDocumentLayout__PaintContext_setSelections(QAbstractTextDocumentLayout__PaintContext* self, struct miqt_array /* of QAbstractTextDocumentLayout__Selection* */  selections) {
+	QList<QAbstractTextDocumentLayout::Selection> selections_QList;
+	selections_QList.reserve(selections.len);
+	QAbstractTextDocumentLayout__Selection** selections_arr = static_cast<QAbstractTextDocumentLayout__Selection**>(selections.data);
+	for(size_t i = 0; i < selections.len; ++i) {
+		selections_QList.push_back(*(selections_arr[i]));
+	}
+	self->selections = selections_QList;
+}
+
+void QAbstractTextDocumentLayout__PaintContext_operatorAssign(QAbstractTextDocumentLayout__PaintContext* self, QAbstractTextDocumentLayout__PaintContext* param1) {
+	self->operator=(*param1);
+}
+
+void QAbstractTextDocumentLayout__PaintContext_delete(QAbstractTextDocumentLayout__PaintContext* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qabstracttextdocumentlayout.h

@@ -0,0 +1,191 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QABSTRACTTEXTDOCUMENTLAYOUT_H
+#define MIQT_QT6_GEN_QABSTRACTTEXTDOCUMENTLAYOUT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractTextDocumentLayout;
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAbstractTextDocumentLayout__PaintContext)
+typedef QAbstractTextDocumentLayout::PaintContext QAbstractTextDocumentLayout__PaintContext;
+#else
+class QAbstractTextDocumentLayout__PaintContext;
+#endif
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAbstractTextDocumentLayout__Selection)
+typedef QAbstractTextDocumentLayout::Selection QAbstractTextDocumentLayout__Selection;
+#else
+class QAbstractTextDocumentLayout__Selection;
+#endif
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QPaintDevice;
+class QPainter;
+class QPalette;
+class QPointF;
+class QRectF;
+class QSizeF;
+class QTextBlock;
+class QTextCharFormat;
+class QTextCursor;
+class QTextDocument;
+class QTextFormat;
+class QTextFrame;
+class QTextInlineObject;
+class QTextObjectInterface;
+class QTimerEvent;
+#else
+typedef struct QAbstractTextDocumentLayout QAbstractTextDocumentLayout;
+typedef struct QAbstractTextDocumentLayout__PaintContext QAbstractTextDocumentLayout__PaintContext;
+typedef struct QAbstractTextDocumentLayout__Selection QAbstractTextDocumentLayout__Selection;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPainter QPainter;
+typedef struct QPalette QPalette;
+typedef struct QPointF QPointF;
+typedef struct QRectF QRectF;
+typedef struct QSizeF QSizeF;
+typedef struct QTextBlock QTextBlock;
+typedef struct QTextCharFormat QTextCharFormat;
+typedef struct QTextCursor QTextCursor;
+typedef struct QTextDocument QTextDocument;
+typedef struct QTextFormat QTextFormat;
+typedef struct QTextFrame QTextFrame;
+typedef struct QTextInlineObject QTextInlineObject;
+typedef struct QTextObjectInterface QTextObjectInterface;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QAbstractTextDocumentLayout* QAbstractTextDocumentLayout_new(QTextDocument* doc);
+void QAbstractTextDocumentLayout_virtbase(QAbstractTextDocumentLayout* src, QObject** outptr_QObject);
+QMetaObject* QAbstractTextDocumentLayout_metaObject(const QAbstractTextDocumentLayout* self);
+void* QAbstractTextDocumentLayout_metacast(QAbstractTextDocumentLayout* self, const char* param1);
+struct miqt_string QAbstractTextDocumentLayout_tr(const char* s);
+void QAbstractTextDocumentLayout_draw(QAbstractTextDocumentLayout* self, QPainter* painter, QAbstractTextDocumentLayout__PaintContext* context);
+int QAbstractTextDocumentLayout_hitTest(const QAbstractTextDocumentLayout* self, QPointF* point, int accuracy);
+struct miqt_string QAbstractTextDocumentLayout_anchorAt(const QAbstractTextDocumentLayout* self, QPointF* pos);
+struct miqt_string QAbstractTextDocumentLayout_imageAt(const QAbstractTextDocumentLayout* self, QPointF* pos);
+QTextFormat* QAbstractTextDocumentLayout_formatAt(const QAbstractTextDocumentLayout* self, QPointF* pos);
+QTextBlock* QAbstractTextDocumentLayout_blockWithMarkerAt(const QAbstractTextDocumentLayout* self, QPointF* pos);
+int QAbstractTextDocumentLayout_pageCount(const QAbstractTextDocumentLayout* self);
+QSizeF* QAbstractTextDocumentLayout_documentSize(const QAbstractTextDocumentLayout* self);
+QRectF* QAbstractTextDocumentLayout_frameBoundingRect(const QAbstractTextDocumentLayout* self, QTextFrame* frame);
+QRectF* QAbstractTextDocumentLayout_blockBoundingRect(const QAbstractTextDocumentLayout* self, QTextBlock* block);
+void QAbstractTextDocumentLayout_setPaintDevice(QAbstractTextDocumentLayout* self, QPaintDevice* device);
+QPaintDevice* QAbstractTextDocumentLayout_paintDevice(const QAbstractTextDocumentLayout* self);
+QTextDocument* QAbstractTextDocumentLayout_document(const QAbstractTextDocumentLayout* self);
+void QAbstractTextDocumentLayout_registerHandler(QAbstractTextDocumentLayout* self, int objectType, QObject* component);
+void QAbstractTextDocumentLayout_unregisterHandler(QAbstractTextDocumentLayout* self, int objectType);
+QTextObjectInterface* QAbstractTextDocumentLayout_handlerForObject(const QAbstractTextDocumentLayout* self, int objectType);
+void QAbstractTextDocumentLayout_update(QAbstractTextDocumentLayout* self);
+void QAbstractTextDocumentLayout_connect_update(QAbstractTextDocumentLayout* self, intptr_t slot);
+void QAbstractTextDocumentLayout_updateBlock(QAbstractTextDocumentLayout* self, QTextBlock* block);
+void QAbstractTextDocumentLayout_connect_updateBlock(QAbstractTextDocumentLayout* self, intptr_t slot);
+void QAbstractTextDocumentLayout_documentSizeChanged(QAbstractTextDocumentLayout* self, QSizeF* newSize);
+void QAbstractTextDocumentLayout_connect_documentSizeChanged(QAbstractTextDocumentLayout* self, intptr_t slot);
+void QAbstractTextDocumentLayout_pageCountChanged(QAbstractTextDocumentLayout* self, int newPages);
+void QAbstractTextDocumentLayout_connect_pageCountChanged(QAbstractTextDocumentLayout* self, intptr_t slot);
+void QAbstractTextDocumentLayout_documentChanged(QAbstractTextDocumentLayout* self, int from, int charsRemoved, int charsAdded);
+void QAbstractTextDocumentLayout_resizeInlineObject(QAbstractTextDocumentLayout* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+void QAbstractTextDocumentLayout_positionInlineObject(QAbstractTextDocumentLayout* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+void QAbstractTextDocumentLayout_drawInlineObject(QAbstractTextDocumentLayout* self, QPainter* painter, QRectF* rect, QTextInlineObject* object, int posInDocument, QTextFormat* format);
+struct miqt_string QAbstractTextDocumentLayout_tr2(const char* s, const char* c);
+struct miqt_string QAbstractTextDocumentLayout_tr3(const char* s, const char* c, int n);
+void QAbstractTextDocumentLayout_unregisterHandler2(QAbstractTextDocumentLayout* self, int objectType, QObject* component);
+void QAbstractTextDocumentLayout_updateWithQRectF(QAbstractTextDocumentLayout* self, QRectF* param1);
+void QAbstractTextDocumentLayout_connect_updateWithQRectF(QAbstractTextDocumentLayout* self, intptr_t slot);
+
+bool QAbstractTextDocumentLayout_override_virtual_draw(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_draw(void* self, QPainter* painter, QAbstractTextDocumentLayout__PaintContext* context);
+bool QAbstractTextDocumentLayout_override_virtual_hitTest(void* self, intptr_t slot);
+int QAbstractTextDocumentLayout_virtualbase_hitTest(const void* self, QPointF* point, int accuracy);
+bool QAbstractTextDocumentLayout_override_virtual_pageCount(void* self, intptr_t slot);
+int QAbstractTextDocumentLayout_virtualbase_pageCount(const void* self);
+bool QAbstractTextDocumentLayout_override_virtual_documentSize(void* self, intptr_t slot);
+QSizeF* QAbstractTextDocumentLayout_virtualbase_documentSize(const void* self);
+bool QAbstractTextDocumentLayout_override_virtual_frameBoundingRect(void* self, intptr_t slot);
+QRectF* QAbstractTextDocumentLayout_virtualbase_frameBoundingRect(const void* self, QTextFrame* frame);
+bool QAbstractTextDocumentLayout_override_virtual_blockBoundingRect(void* self, intptr_t slot);
+QRectF* QAbstractTextDocumentLayout_virtualbase_blockBoundingRect(const void* self, QTextBlock* block);
+bool QAbstractTextDocumentLayout_override_virtual_documentChanged(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_documentChanged(void* self, int from, int charsRemoved, int charsAdded);
+bool QAbstractTextDocumentLayout_override_virtual_resizeInlineObject(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_resizeInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+bool QAbstractTextDocumentLayout_override_virtual_positionInlineObject(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_positionInlineObject(void* self, QTextInlineObject* item, int posInDocument, QTextFormat* format);
+bool QAbstractTextDocumentLayout_override_virtual_drawInlineObject(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_drawInlineObject(void* self, QPainter* painter, QRectF* rect, QTextInlineObject* object, int posInDocument, QTextFormat* format);
+bool QAbstractTextDocumentLayout_override_virtual_event(void* self, intptr_t slot);
+bool QAbstractTextDocumentLayout_virtualbase_event(void* self, QEvent* event);
+bool QAbstractTextDocumentLayout_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAbstractTextDocumentLayout_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAbstractTextDocumentLayout_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAbstractTextDocumentLayout_override_virtual_childEvent(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAbstractTextDocumentLayout_override_virtual_customEvent(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_customEvent(void* self, QEvent* event);
+bool QAbstractTextDocumentLayout_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAbstractTextDocumentLayout_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAbstractTextDocumentLayout_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+int QAbstractTextDocumentLayout_protectedbase_formatIndex(bool* _dynamic_cast_ok, void* self, int pos);
+QTextCharFormat* QAbstractTextDocumentLayout_protectedbase_format(bool* _dynamic_cast_ok, void* self, int pos);
+QObject* QAbstractTextDocumentLayout_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAbstractTextDocumentLayout_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAbstractTextDocumentLayout_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAbstractTextDocumentLayout_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAbstractTextDocumentLayout_delete(QAbstractTextDocumentLayout* self);
+
+QSizeF* QTextObjectInterface_intrinsicSize(QTextObjectInterface* self, QTextDocument* doc, int posInDocument, QTextFormat* format);
+void QTextObjectInterface_drawObject(QTextObjectInterface* self, QPainter* painter, QRectF* rect, QTextDocument* doc, int posInDocument, QTextFormat* format);
+void QTextObjectInterface_operatorAssign(QTextObjectInterface* self, QTextObjectInterface* param1);
+
+void QTextObjectInterface_delete(QTextObjectInterface* self);
+
+QAbstractTextDocumentLayout__Selection* QAbstractTextDocumentLayout__Selection_new(QAbstractTextDocumentLayout__Selection* param1);
+QTextCursor* QAbstractTextDocumentLayout__Selection_cursor(const QAbstractTextDocumentLayout__Selection* self);
+void QAbstractTextDocumentLayout__Selection_setCursor(QAbstractTextDocumentLayout__Selection* self, QTextCursor* cursor);
+QTextCharFormat* QAbstractTextDocumentLayout__Selection_format(const QAbstractTextDocumentLayout__Selection* self);
+void QAbstractTextDocumentLayout__Selection_setFormat(QAbstractTextDocumentLayout__Selection* self, QTextCharFormat* format);
+void QAbstractTextDocumentLayout__Selection_operatorAssign(QAbstractTextDocumentLayout__Selection* self, QAbstractTextDocumentLayout__Selection* param1);
+
+void QAbstractTextDocumentLayout__Selection_delete(QAbstractTextDocumentLayout__Selection* self);
+
+QAbstractTextDocumentLayout__PaintContext* QAbstractTextDocumentLayout__PaintContext_new();
+QAbstractTextDocumentLayout__PaintContext* QAbstractTextDocumentLayout__PaintContext_new2(QAbstractTextDocumentLayout__PaintContext* param1);
+int QAbstractTextDocumentLayout__PaintContext_cursorPosition(const QAbstractTextDocumentLayout__PaintContext* self);
+void QAbstractTextDocumentLayout__PaintContext_setCursorPosition(QAbstractTextDocumentLayout__PaintContext* self, int cursorPosition);
+QPalette* QAbstractTextDocumentLayout__PaintContext_palette(const QAbstractTextDocumentLayout__PaintContext* self);
+void QAbstractTextDocumentLayout__PaintContext_setPalette(QAbstractTextDocumentLayout__PaintContext* self, QPalette* palette);
+QRectF* QAbstractTextDocumentLayout__PaintContext_clip(const QAbstractTextDocumentLayout__PaintContext* self);
+void QAbstractTextDocumentLayout__PaintContext_setClip(QAbstractTextDocumentLayout__PaintContext* self, QRectF* clip);
+struct miqt_array /* of QAbstractTextDocumentLayout__Selection* */  QAbstractTextDocumentLayout__PaintContext_selections(const QAbstractTextDocumentLayout__PaintContext* self);
+void QAbstractTextDocumentLayout__PaintContext_setSelections(QAbstractTextDocumentLayout__PaintContext* self, struct miqt_array /* of QAbstractTextDocumentLayout__Selection* */  selections);
+void QAbstractTextDocumentLayout__PaintContext_operatorAssign(QAbstractTextDocumentLayout__PaintContext* self, QAbstractTextDocumentLayout__PaintContext* param1);
+
+void QAbstractTextDocumentLayout__PaintContext_delete(QAbstractTextDocumentLayout__PaintContext* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessible.h

@@ -0,0 +1,334 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLE_H
+#define MIQT_QT6_GEN_QACCESSIBLE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State)
+typedef QAccessible::State QAccessible__State;
+#else
+class QAccessible__State;
+#endif
+class QAccessibleActionInterface;
+class QAccessibleEditableTextInterface;
+class QAccessibleEvent;
+class QAccessibleHyperlinkInterface;
+class QAccessibleImageInterface;
+class QAccessibleInterface;
+class QAccessibleStateChangeEvent;
+class QAccessibleTableCellInterface;
+class QAccessibleTableInterface;
+class QAccessibleTableModelChangeEvent;
+class QAccessibleTextCursorEvent;
+class QAccessibleTextInsertEvent;
+class QAccessibleTextInterface;
+class QAccessibleTextRemoveEvent;
+class QAccessibleTextSelectionEvent;
+class QAccessibleTextUpdateEvent;
+class QAccessibleValueChangeEvent;
+class QAccessibleValueInterface;
+class QColor;
+class QObject;
+class QPoint;
+class QRect;
+class QSize;
+class QVariant;
+class QWindow;
+#else
+typedef struct QAccessible__State QAccessible__State;
+typedef struct QAccessibleActionInterface QAccessibleActionInterface;
+typedef struct QAccessibleEditableTextInterface QAccessibleEditableTextInterface;
+typedef struct QAccessibleEvent QAccessibleEvent;
+typedef struct QAccessibleHyperlinkInterface QAccessibleHyperlinkInterface;
+typedef struct QAccessibleImageInterface QAccessibleImageInterface;
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QAccessibleStateChangeEvent QAccessibleStateChangeEvent;
+typedef struct QAccessibleTableCellInterface QAccessibleTableCellInterface;
+typedef struct QAccessibleTableInterface QAccessibleTableInterface;
+typedef struct QAccessibleTableModelChangeEvent QAccessibleTableModelChangeEvent;
+typedef struct QAccessibleTextCursorEvent QAccessibleTextCursorEvent;
+typedef struct QAccessibleTextInsertEvent QAccessibleTextInsertEvent;
+typedef struct QAccessibleTextInterface QAccessibleTextInterface;
+typedef struct QAccessibleTextRemoveEvent QAccessibleTextRemoveEvent;
+typedef struct QAccessibleTextSelectionEvent QAccessibleTextSelectionEvent;
+typedef struct QAccessibleTextUpdateEvent QAccessibleTextUpdateEvent;
+typedef struct QAccessibleValueChangeEvent QAccessibleValueChangeEvent;
+typedef struct QAccessibleValueInterface QAccessibleValueInterface;
+typedef struct QColor QColor;
+typedef struct QObject QObject;
+typedef struct QPoint QPoint;
+typedef struct QRect QRect;
+typedef struct QSize QSize;
+typedef struct QVariant QVariant;
+typedef struct QWindow QWindow;
+#endif
+
+bool QAccessibleInterface_isValid(const QAccessibleInterface* self);
+QObject* QAccessibleInterface_object(const QAccessibleInterface* self);
+QWindow* QAccessibleInterface_window(const QAccessibleInterface* self);
+struct miqt_array /* of struct miqt_map  tuple of QAccessibleInterface* and int   */  QAccessibleInterface_relations(const QAccessibleInterface* self, int match);
+QAccessibleInterface* QAccessibleInterface_focusChild(const QAccessibleInterface* self);
+QAccessibleInterface* QAccessibleInterface_childAt(const QAccessibleInterface* self, int x, int y);
+QAccessibleInterface* QAccessibleInterface_parent(const QAccessibleInterface* self);
+QAccessibleInterface* QAccessibleInterface_child(const QAccessibleInterface* self, int index);
+int QAccessibleInterface_childCount(const QAccessibleInterface* self);
+int QAccessibleInterface_indexOfChild(const QAccessibleInterface* self, QAccessibleInterface* param1);
+struct miqt_string QAccessibleInterface_text(const QAccessibleInterface* self, int t);
+void QAccessibleInterface_setText(QAccessibleInterface* self, int t, struct miqt_string text);
+QRect* QAccessibleInterface_rect(const QAccessibleInterface* self);
+int QAccessibleInterface_role(const QAccessibleInterface* self);
+QAccessible__State* QAccessibleInterface_state(const QAccessibleInterface* self);
+QColor* QAccessibleInterface_foregroundColor(const QAccessibleInterface* self);
+QColor* QAccessibleInterface_backgroundColor(const QAccessibleInterface* self);
+QAccessibleTextInterface* QAccessibleInterface_textInterface(QAccessibleInterface* self);
+QAccessibleEditableTextInterface* QAccessibleInterface_editableTextInterface(QAccessibleInterface* self);
+QAccessibleValueInterface* QAccessibleInterface_valueInterface(QAccessibleInterface* self);
+QAccessibleActionInterface* QAccessibleInterface_actionInterface(QAccessibleInterface* self);
+QAccessibleImageInterface* QAccessibleInterface_imageInterface(QAccessibleInterface* self);
+QAccessibleTableInterface* QAccessibleInterface_tableInterface(QAccessibleInterface* self);
+QAccessibleTableCellInterface* QAccessibleInterface_tableCellInterface(QAccessibleInterface* self);
+QAccessibleHyperlinkInterface* QAccessibleInterface_hyperlinkInterface(QAccessibleInterface* self);
+void QAccessibleInterface_virtualHook(QAccessibleInterface* self, int id, void* data);
+void* QAccessibleInterface_interfaceCast(QAccessibleInterface* self, int param1);
+void QAccessibleInterface_operatorAssign(QAccessibleInterface* self, QAccessibleInterface* param1);
+
+
+void QAccessibleTextInterface_selection(const QAccessibleTextInterface* self, int selectionIndex, int* startOffset, int* endOffset);
+int QAccessibleTextInterface_selectionCount(const QAccessibleTextInterface* self);
+void QAccessibleTextInterface_addSelection(QAccessibleTextInterface* self, int startOffset, int endOffset);
+void QAccessibleTextInterface_removeSelection(QAccessibleTextInterface* self, int selectionIndex);
+void QAccessibleTextInterface_setSelection(QAccessibleTextInterface* self, int selectionIndex, int startOffset, int endOffset);
+int QAccessibleTextInterface_cursorPosition(const QAccessibleTextInterface* self);
+void QAccessibleTextInterface_setCursorPosition(QAccessibleTextInterface* self, int position);
+struct miqt_string QAccessibleTextInterface_text(const QAccessibleTextInterface* self, int startOffset, int endOffset);
+struct miqt_string QAccessibleTextInterface_textBeforeOffset(const QAccessibleTextInterface* self, int offset, int boundaryType, int* startOffset, int* endOffset);
+struct miqt_string QAccessibleTextInterface_textAfterOffset(const QAccessibleTextInterface* self, int offset, int boundaryType, int* startOffset, int* endOffset);
+struct miqt_string QAccessibleTextInterface_textAtOffset(const QAccessibleTextInterface* self, int offset, int boundaryType, int* startOffset, int* endOffset);
+int QAccessibleTextInterface_characterCount(const QAccessibleTextInterface* self);
+QRect* QAccessibleTextInterface_characterRect(const QAccessibleTextInterface* self, int offset);
+int QAccessibleTextInterface_offsetAtPoint(const QAccessibleTextInterface* self, QPoint* point);
+void QAccessibleTextInterface_scrollToSubstring(QAccessibleTextInterface* self, int startIndex, int endIndex);
+struct miqt_string QAccessibleTextInterface_attributes(const QAccessibleTextInterface* self, int offset, int* startOffset, int* endOffset);
+void QAccessibleTextInterface_operatorAssign(QAccessibleTextInterface* self, QAccessibleTextInterface* param1);
+
+void QAccessibleTextInterface_delete(QAccessibleTextInterface* self);
+
+void QAccessibleEditableTextInterface_deleteText(QAccessibleEditableTextInterface* self, int startOffset, int endOffset);
+void QAccessibleEditableTextInterface_insertText(QAccessibleEditableTextInterface* self, int offset, struct miqt_string text);
+void QAccessibleEditableTextInterface_replaceText(QAccessibleEditableTextInterface* self, int startOffset, int endOffset, struct miqt_string text);
+void QAccessibleEditableTextInterface_operatorAssign(QAccessibleEditableTextInterface* self, QAccessibleEditableTextInterface* param1);
+
+void QAccessibleEditableTextInterface_delete(QAccessibleEditableTextInterface* self);
+
+QVariant* QAccessibleValueInterface_currentValue(const QAccessibleValueInterface* self);
+void QAccessibleValueInterface_setCurrentValue(QAccessibleValueInterface* self, QVariant* value);
+QVariant* QAccessibleValueInterface_maximumValue(const QAccessibleValueInterface* self);
+QVariant* QAccessibleValueInterface_minimumValue(const QAccessibleValueInterface* self);
+QVariant* QAccessibleValueInterface_minimumStepSize(const QAccessibleValueInterface* self);
+void QAccessibleValueInterface_operatorAssign(QAccessibleValueInterface* self, QAccessibleValueInterface* param1);
+
+void QAccessibleValueInterface_delete(QAccessibleValueInterface* self);
+
+bool QAccessibleTableCellInterface_isSelected(const QAccessibleTableCellInterface* self);
+struct miqt_array /* of QAccessibleInterface* */  QAccessibleTableCellInterface_columnHeaderCells(const QAccessibleTableCellInterface* self);
+struct miqt_array /* of QAccessibleInterface* */  QAccessibleTableCellInterface_rowHeaderCells(const QAccessibleTableCellInterface* self);
+int QAccessibleTableCellInterface_columnIndex(const QAccessibleTableCellInterface* self);
+int QAccessibleTableCellInterface_rowIndex(const QAccessibleTableCellInterface* self);
+int QAccessibleTableCellInterface_columnExtent(const QAccessibleTableCellInterface* self);
+int QAccessibleTableCellInterface_rowExtent(const QAccessibleTableCellInterface* self);
+QAccessibleInterface* QAccessibleTableCellInterface_table(const QAccessibleTableCellInterface* self);
+void QAccessibleTableCellInterface_operatorAssign(QAccessibleTableCellInterface* self, QAccessibleTableCellInterface* param1);
+
+void QAccessibleTableCellInterface_delete(QAccessibleTableCellInterface* self);
+
+QAccessibleInterface* QAccessibleTableInterface_caption(const QAccessibleTableInterface* self);
+QAccessibleInterface* QAccessibleTableInterface_summary(const QAccessibleTableInterface* self);
+QAccessibleInterface* QAccessibleTableInterface_cellAt(const QAccessibleTableInterface* self, int row, int column);
+int QAccessibleTableInterface_selectedCellCount(const QAccessibleTableInterface* self);
+struct miqt_array /* of QAccessibleInterface* */  QAccessibleTableInterface_selectedCells(const QAccessibleTableInterface* self);
+struct miqt_string QAccessibleTableInterface_columnDescription(const QAccessibleTableInterface* self, int column);
+struct miqt_string QAccessibleTableInterface_rowDescription(const QAccessibleTableInterface* self, int row);
+int QAccessibleTableInterface_selectedColumnCount(const QAccessibleTableInterface* self);
+int QAccessibleTableInterface_selectedRowCount(const QAccessibleTableInterface* self);
+int QAccessibleTableInterface_columnCount(const QAccessibleTableInterface* self);
+int QAccessibleTableInterface_rowCount(const QAccessibleTableInterface* self);
+struct miqt_array /* of int */  QAccessibleTableInterface_selectedColumns(const QAccessibleTableInterface* self);
+struct miqt_array /* of int */  QAccessibleTableInterface_selectedRows(const QAccessibleTableInterface* self);
+bool QAccessibleTableInterface_isColumnSelected(const QAccessibleTableInterface* self, int column);
+bool QAccessibleTableInterface_isRowSelected(const QAccessibleTableInterface* self, int row);
+bool QAccessibleTableInterface_selectRow(QAccessibleTableInterface* self, int row);
+bool QAccessibleTableInterface_selectColumn(QAccessibleTableInterface* self, int column);
+bool QAccessibleTableInterface_unselectRow(QAccessibleTableInterface* self, int row);
+bool QAccessibleTableInterface_unselectColumn(QAccessibleTableInterface* self, int column);
+void QAccessibleTableInterface_modelChange(QAccessibleTableInterface* self, QAccessibleTableModelChangeEvent* event);
+void QAccessibleTableInterface_operatorAssign(QAccessibleTableInterface* self, QAccessibleTableInterface* param1);
+
+void QAccessibleTableInterface_delete(QAccessibleTableInterface* self);
+
+struct miqt_string QAccessibleActionInterface_tr(const char* sourceText);
+struct miqt_array /* of struct miqt_string */  QAccessibleActionInterface_actionNames(const QAccessibleActionInterface* self);
+struct miqt_string QAccessibleActionInterface_localizedActionName(const QAccessibleActionInterface* self, struct miqt_string name);
+struct miqt_string QAccessibleActionInterface_localizedActionDescription(const QAccessibleActionInterface* self, struct miqt_string name);
+void QAccessibleActionInterface_doAction(QAccessibleActionInterface* self, struct miqt_string actionName);
+struct miqt_array /* of struct miqt_string */  QAccessibleActionInterface_keyBindingsForAction(const QAccessibleActionInterface* self, struct miqt_string actionName);
+struct miqt_string QAccessibleActionInterface_pressAction();
+struct miqt_string QAccessibleActionInterface_increaseAction();
+struct miqt_string QAccessibleActionInterface_decreaseAction();
+struct miqt_string QAccessibleActionInterface_showMenuAction();
+struct miqt_string QAccessibleActionInterface_setFocusAction();
+struct miqt_string QAccessibleActionInterface_toggleAction();
+struct miqt_string QAccessibleActionInterface_scrollLeftAction();
+struct miqt_string QAccessibleActionInterface_scrollRightAction();
+struct miqt_string QAccessibleActionInterface_scrollUpAction();
+struct miqt_string QAccessibleActionInterface_scrollDownAction();
+struct miqt_string QAccessibleActionInterface_nextPageAction();
+struct miqt_string QAccessibleActionInterface_previousPageAction();
+void QAccessibleActionInterface_operatorAssign(QAccessibleActionInterface* self, QAccessibleActionInterface* param1);
+struct miqt_string QAccessibleActionInterface_tr2(const char* sourceText, const char* disambiguation);
+struct miqt_string QAccessibleActionInterface_tr3(const char* sourceText, const char* disambiguation, int n);
+
+void QAccessibleActionInterface_delete(QAccessibleActionInterface* self);
+
+struct miqt_string QAccessibleImageInterface_imageDescription(const QAccessibleImageInterface* self);
+QSize* QAccessibleImageInterface_imageSize(const QAccessibleImageInterface* self);
+QPoint* QAccessibleImageInterface_imagePosition(const QAccessibleImageInterface* self);
+void QAccessibleImageInterface_operatorAssign(QAccessibleImageInterface* self, QAccessibleImageInterface* param1);
+
+void QAccessibleImageInterface_delete(QAccessibleImageInterface* self);
+
+struct miqt_string QAccessibleHyperlinkInterface_anchor(const QAccessibleHyperlinkInterface* self);
+struct miqt_string QAccessibleHyperlinkInterface_anchorTarget(const QAccessibleHyperlinkInterface* self);
+int QAccessibleHyperlinkInterface_startIndex(const QAccessibleHyperlinkInterface* self);
+int QAccessibleHyperlinkInterface_endIndex(const QAccessibleHyperlinkInterface* self);
+bool QAccessibleHyperlinkInterface_isValid(const QAccessibleHyperlinkInterface* self);
+void QAccessibleHyperlinkInterface_operatorAssign(QAccessibleHyperlinkInterface* self, QAccessibleHyperlinkInterface* param1);
+
+void QAccessibleHyperlinkInterface_delete(QAccessibleHyperlinkInterface* self);
+
+QAccessibleEvent* QAccessibleEvent_new(QObject* obj, int typ);
+QAccessibleEvent* QAccessibleEvent_new2(QAccessibleInterface* iface, int typ);
+int QAccessibleEvent_type(const QAccessibleEvent* self);
+QObject* QAccessibleEvent_object(const QAccessibleEvent* self);
+unsigned int QAccessibleEvent_uniqueId(const QAccessibleEvent* self);
+void QAccessibleEvent_setChild(QAccessibleEvent* self, int chld);
+int QAccessibleEvent_child(const QAccessibleEvent* self);
+QAccessibleInterface* QAccessibleEvent_accessibleInterface(const QAccessibleEvent* self);
+
+bool QAccessibleEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleEvent_delete(QAccessibleEvent* self);
+
+QAccessibleStateChangeEvent* QAccessibleStateChangeEvent_new(QObject* obj, QAccessible__State* state);
+QAccessibleStateChangeEvent* QAccessibleStateChangeEvent_new2(QAccessibleInterface* iface, QAccessible__State* state);
+void QAccessibleStateChangeEvent_virtbase(QAccessibleStateChangeEvent* src, QAccessibleEvent** outptr_QAccessibleEvent);
+QAccessible__State* QAccessibleStateChangeEvent_changedStates(const QAccessibleStateChangeEvent* self);
+
+bool QAccessibleStateChangeEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleStateChangeEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleStateChangeEvent_delete(QAccessibleStateChangeEvent* self);
+
+QAccessibleTextCursorEvent* QAccessibleTextCursorEvent_new(QObject* obj, int cursorPos);
+QAccessibleTextCursorEvent* QAccessibleTextCursorEvent_new2(QAccessibleInterface* iface, int cursorPos);
+void QAccessibleTextCursorEvent_virtbase(QAccessibleTextCursorEvent* src, QAccessibleEvent** outptr_QAccessibleEvent);
+void QAccessibleTextCursorEvent_setCursorPosition(QAccessibleTextCursorEvent* self, int position);
+int QAccessibleTextCursorEvent_cursorPosition(const QAccessibleTextCursorEvent* self);
+
+bool QAccessibleTextCursorEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTextCursorEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTextCursorEvent_delete(QAccessibleTextCursorEvent* self);
+
+QAccessibleTextSelectionEvent* QAccessibleTextSelectionEvent_new(QObject* obj, int start, int end);
+QAccessibleTextSelectionEvent* QAccessibleTextSelectionEvent_new2(QAccessibleInterface* iface, int start, int end);
+void QAccessibleTextSelectionEvent_virtbase(QAccessibleTextSelectionEvent* src, QAccessibleTextCursorEvent** outptr_QAccessibleTextCursorEvent);
+void QAccessibleTextSelectionEvent_setSelection(QAccessibleTextSelectionEvent* self, int start, int end);
+int QAccessibleTextSelectionEvent_selectionStart(const QAccessibleTextSelectionEvent* self);
+int QAccessibleTextSelectionEvent_selectionEnd(const QAccessibleTextSelectionEvent* self);
+
+bool QAccessibleTextSelectionEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTextSelectionEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTextSelectionEvent_delete(QAccessibleTextSelectionEvent* self);
+
+QAccessibleTextInsertEvent* QAccessibleTextInsertEvent_new(QObject* obj, int position, struct miqt_string text);
+QAccessibleTextInsertEvent* QAccessibleTextInsertEvent_new2(QAccessibleInterface* iface, int position, struct miqt_string text);
+void QAccessibleTextInsertEvent_virtbase(QAccessibleTextInsertEvent* src, QAccessibleTextCursorEvent** outptr_QAccessibleTextCursorEvent);
+struct miqt_string QAccessibleTextInsertEvent_textInserted(const QAccessibleTextInsertEvent* self);
+int QAccessibleTextInsertEvent_changePosition(const QAccessibleTextInsertEvent* self);
+
+bool QAccessibleTextInsertEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTextInsertEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTextInsertEvent_delete(QAccessibleTextInsertEvent* self);
+
+QAccessibleTextRemoveEvent* QAccessibleTextRemoveEvent_new(QObject* obj, int position, struct miqt_string text);
+QAccessibleTextRemoveEvent* QAccessibleTextRemoveEvent_new2(QAccessibleInterface* iface, int position, struct miqt_string text);
+void QAccessibleTextRemoveEvent_virtbase(QAccessibleTextRemoveEvent* src, QAccessibleTextCursorEvent** outptr_QAccessibleTextCursorEvent);
+struct miqt_string QAccessibleTextRemoveEvent_textRemoved(const QAccessibleTextRemoveEvent* self);
+int QAccessibleTextRemoveEvent_changePosition(const QAccessibleTextRemoveEvent* self);
+
+bool QAccessibleTextRemoveEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTextRemoveEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTextRemoveEvent_delete(QAccessibleTextRemoveEvent* self);
+
+QAccessibleTextUpdateEvent* QAccessibleTextUpdateEvent_new(QObject* obj, int position, struct miqt_string oldText, struct miqt_string text);
+QAccessibleTextUpdateEvent* QAccessibleTextUpdateEvent_new2(QAccessibleInterface* iface, int position, struct miqt_string oldText, struct miqt_string text);
+void QAccessibleTextUpdateEvent_virtbase(QAccessibleTextUpdateEvent* src, QAccessibleTextCursorEvent** outptr_QAccessibleTextCursorEvent);
+struct miqt_string QAccessibleTextUpdateEvent_textRemoved(const QAccessibleTextUpdateEvent* self);
+struct miqt_string QAccessibleTextUpdateEvent_textInserted(const QAccessibleTextUpdateEvent* self);
+int QAccessibleTextUpdateEvent_changePosition(const QAccessibleTextUpdateEvent* self);
+
+bool QAccessibleTextUpdateEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTextUpdateEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTextUpdateEvent_delete(QAccessibleTextUpdateEvent* self);
+
+QAccessibleValueChangeEvent* QAccessibleValueChangeEvent_new(QObject* obj, QVariant* val);
+QAccessibleValueChangeEvent* QAccessibleValueChangeEvent_new2(QAccessibleInterface* iface, QVariant* val);
+void QAccessibleValueChangeEvent_virtbase(QAccessibleValueChangeEvent* src, QAccessibleEvent** outptr_QAccessibleEvent);
+void QAccessibleValueChangeEvent_setValue(QAccessibleValueChangeEvent* self, QVariant* val);
+QVariant* QAccessibleValueChangeEvent_value(const QAccessibleValueChangeEvent* self);
+
+bool QAccessibleValueChangeEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleValueChangeEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleValueChangeEvent_delete(QAccessibleValueChangeEvent* self);
+
+QAccessibleTableModelChangeEvent* QAccessibleTableModelChangeEvent_new(QObject* obj, int changeType);
+QAccessibleTableModelChangeEvent* QAccessibleTableModelChangeEvent_new2(QAccessibleInterface* iface, int changeType);
+void QAccessibleTableModelChangeEvent_virtbase(QAccessibleTableModelChangeEvent* src, QAccessibleEvent** outptr_QAccessibleEvent);
+void QAccessibleTableModelChangeEvent_setModelChangeType(QAccessibleTableModelChangeEvent* self, int changeType);
+int QAccessibleTableModelChangeEvent_modelChangeType(const QAccessibleTableModelChangeEvent* self);
+void QAccessibleTableModelChangeEvent_setFirstRow(QAccessibleTableModelChangeEvent* self, int row);
+void QAccessibleTableModelChangeEvent_setFirstColumn(QAccessibleTableModelChangeEvent* self, int col);
+void QAccessibleTableModelChangeEvent_setLastRow(QAccessibleTableModelChangeEvent* self, int row);
+void QAccessibleTableModelChangeEvent_setLastColumn(QAccessibleTableModelChangeEvent* self, int col);
+int QAccessibleTableModelChangeEvent_firstRow(const QAccessibleTableModelChangeEvent* self);
+int QAccessibleTableModelChangeEvent_firstColumn(const QAccessibleTableModelChangeEvent* self);
+int QAccessibleTableModelChangeEvent_lastRow(const QAccessibleTableModelChangeEvent* self);
+int QAccessibleTableModelChangeEvent_lastColumn(const QAccessibleTableModelChangeEvent* self);
+
+bool QAccessibleTableModelChangeEvent_override_virtual_accessibleInterface(void* self, intptr_t slot);
+QAccessibleInterface* QAccessibleTableModelChangeEvent_virtualbase_accessibleInterface(const void* self);
+
+void QAccessibleTableModelChangeEvent_delete(QAccessibleTableModelChangeEvent* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessible_base.cpp

@@ -0,0 +1,440 @@
+#include <QAccessible>
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__ActivationObserver
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State
+#include <QAccessibleEvent>
+#include <QAccessibleInterface>
+#include <QObject>
+#include <QPair>
+#include <QTextCursor>
+#include <qaccessible_base.h>
+#include "gen_qaccessible_base.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+void QAccessible_installActivationObserver(QAccessible__ActivationObserver* param1) {
+	QAccessible::installActivationObserver(param1);
+}
+
+void QAccessible_removeActivationObserver(QAccessible__ActivationObserver* param1) {
+	QAccessible::removeActivationObserver(param1);
+}
+
+QAccessibleInterface* QAccessible_queryAccessibleInterface(QObject* param1) {
+	return QAccessible::queryAccessibleInterface(param1);
+}
+
+unsigned int QAccessible_uniqueId(QAccessibleInterface* iface) {
+	QAccessible::Id _ret = QAccessible::uniqueId(iface);
+	return static_cast<unsigned int>(_ret);
+}
+
+QAccessibleInterface* QAccessible_accessibleInterface(unsigned int uniqueId) {
+	return QAccessible::accessibleInterface(static_cast<QAccessible::Id>(uniqueId));
+}
+
+unsigned int QAccessible_registerAccessibleInterface(QAccessibleInterface* iface) {
+	QAccessible::Id _ret = QAccessible::registerAccessibleInterface(iface);
+	return static_cast<unsigned int>(_ret);
+}
+
+void QAccessible_deleteAccessibleInterface(unsigned int uniqueId) {
+	QAccessible::deleteAccessibleInterface(static_cast<QAccessible::Id>(uniqueId));
+}
+
+void QAccessible_updateAccessibility(QAccessibleEvent* event) {
+	QAccessible::updateAccessibility(event);
+}
+
+bool QAccessible_isActive() {
+	return QAccessible::isActive();
+}
+
+void QAccessible_setActive(bool active) {
+	QAccessible::setActive(active);
+}
+
+void QAccessible_setRootObject(QObject* object) {
+	QAccessible::setRootObject(object);
+}
+
+void QAccessible_cleanup() {
+	QAccessible::cleanup();
+}
+
+struct miqt_map /* tuple of int and int */  QAccessible_qAccessibleTextBoundaryHelper(QTextCursor* cursor, int boundaryType) {
+	QPair<int, int> _ret = QAccessible::qAccessibleTextBoundaryHelper(*cursor, static_cast<QAccessible::TextBoundaryType>(boundaryType));
+	// Convert QPair<> from C++ memory to manually-managed C memory
+	int* _first_arr = static_cast<int*>(malloc(sizeof(int)));
+	int* _second_arr = static_cast<int*>(malloc(sizeof(int)));
+	_first_arr[0] = _ret.first;
+	_second_arr[0] = _ret.second;
+	struct miqt_map _out;
+	_out.len = 1;
+	_out.keys = static_cast<void*>(_first_arr);
+	_out.values = static_cast<void*>(_second_arr);
+	return _out;
+}
+
+void QAccessible_delete(QAccessible* self) {
+	delete self;
+}
+
+QAccessible__State* QAccessible__State_new() {
+	return new (std::nothrow) QAccessible::State();
+}
+
+unsigned long long QAccessible__State_disabled(const QAccessible__State* self) {
+	quint64 disabled_ret = self->disabled;
+	return static_cast<unsigned long long>(disabled_ret);
+}
+
+void QAccessible__State_setDisabled(QAccessible__State* self, unsigned long long disabled) {
+	self->disabled = static_cast<quint64>(disabled);
+}
+
+unsigned long long QAccessible__State_selected(const QAccessible__State* self) {
+	quint64 selected_ret = self->selected;
+	return static_cast<unsigned long long>(selected_ret);
+}
+
+void QAccessible__State_setSelected(QAccessible__State* self, unsigned long long selected) {
+	self->selected = static_cast<quint64>(selected);
+}
+
+unsigned long long QAccessible__State_focusable(const QAccessible__State* self) {
+	quint64 focusable_ret = self->focusable;
+	return static_cast<unsigned long long>(focusable_ret);
+}
+
+void QAccessible__State_setFocusable(QAccessible__State* self, unsigned long long focusable) {
+	self->focusable = static_cast<quint64>(focusable);
+}
+
+unsigned long long QAccessible__State_focused(const QAccessible__State* self) {
+	quint64 focused_ret = self->focused;
+	return static_cast<unsigned long long>(focused_ret);
+}
+
+void QAccessible__State_setFocused(QAccessible__State* self, unsigned long long focused) {
+	self->focused = static_cast<quint64>(focused);
+}
+
+unsigned long long QAccessible__State_pressed(const QAccessible__State* self) {
+	quint64 pressed_ret = self->pressed;
+	return static_cast<unsigned long long>(pressed_ret);
+}
+
+void QAccessible__State_setPressed(QAccessible__State* self, unsigned long long pressed) {
+	self->pressed = static_cast<quint64>(pressed);
+}
+
+unsigned long long QAccessible__State_checkable(const QAccessible__State* self) {
+	quint64 checkable_ret = self->checkable;
+	return static_cast<unsigned long long>(checkable_ret);
+}
+
+void QAccessible__State_setCheckable(QAccessible__State* self, unsigned long long checkable) {
+	self->checkable = static_cast<quint64>(checkable);
+}
+
+unsigned long long QAccessible__State_checked(const QAccessible__State* self) {
+	quint64 checked_ret = self->checked;
+	return static_cast<unsigned long long>(checked_ret);
+}
+
+void QAccessible__State_setChecked(QAccessible__State* self, unsigned long long checked) {
+	self->checked = static_cast<quint64>(checked);
+}
+
+unsigned long long QAccessible__State_checkStateMixed(const QAccessible__State* self) {
+	quint64 checkStateMixed_ret = self->checkStateMixed;
+	return static_cast<unsigned long long>(checkStateMixed_ret);
+}
+
+void QAccessible__State_setCheckStateMixed(QAccessible__State* self, unsigned long long checkStateMixed) {
+	self->checkStateMixed = static_cast<quint64>(checkStateMixed);
+}
+
+unsigned long long QAccessible__State_readOnly(const QAccessible__State* self) {
+	quint64 readOnly_ret = self->readOnly;
+	return static_cast<unsigned long long>(readOnly_ret);
+}
+
+void QAccessible__State_setReadOnly(QAccessible__State* self, unsigned long long readOnly) {
+	self->readOnly = static_cast<quint64>(readOnly);
+}
+
+unsigned long long QAccessible__State_hotTracked(const QAccessible__State* self) {
+	quint64 hotTracked_ret = self->hotTracked;
+	return static_cast<unsigned long long>(hotTracked_ret);
+}
+
+void QAccessible__State_setHotTracked(QAccessible__State* self, unsigned long long hotTracked) {
+	self->hotTracked = static_cast<quint64>(hotTracked);
+}
+
+unsigned long long QAccessible__State_defaultButton(const QAccessible__State* self) {
+	quint64 defaultButton_ret = self->defaultButton;
+	return static_cast<unsigned long long>(defaultButton_ret);
+}
+
+void QAccessible__State_setDefaultButton(QAccessible__State* self, unsigned long long defaultButton) {
+	self->defaultButton = static_cast<quint64>(defaultButton);
+}
+
+unsigned long long QAccessible__State_expanded(const QAccessible__State* self) {
+	quint64 expanded_ret = self->expanded;
+	return static_cast<unsigned long long>(expanded_ret);
+}
+
+void QAccessible__State_setExpanded(QAccessible__State* self, unsigned long long expanded) {
+	self->expanded = static_cast<quint64>(expanded);
+}
+
+unsigned long long QAccessible__State_collapsed(const QAccessible__State* self) {
+	quint64 collapsed_ret = self->collapsed;
+	return static_cast<unsigned long long>(collapsed_ret);
+}
+
+void QAccessible__State_setCollapsed(QAccessible__State* self, unsigned long long collapsed) {
+	self->collapsed = static_cast<quint64>(collapsed);
+}
+
+unsigned long long QAccessible__State_busy(const QAccessible__State* self) {
+	quint64 busy_ret = self->busy;
+	return static_cast<unsigned long long>(busy_ret);
+}
+
+void QAccessible__State_setBusy(QAccessible__State* self, unsigned long long busy) {
+	self->busy = static_cast<quint64>(busy);
+}
+
+unsigned long long QAccessible__State_expandable(const QAccessible__State* self) {
+	quint64 expandable_ret = self->expandable;
+	return static_cast<unsigned long long>(expandable_ret);
+}
+
+void QAccessible__State_setExpandable(QAccessible__State* self, unsigned long long expandable) {
+	self->expandable = static_cast<quint64>(expandable);
+}
+
+unsigned long long QAccessible__State_marqueed(const QAccessible__State* self) {
+	quint64 marqueed_ret = self->marqueed;
+	return static_cast<unsigned long long>(marqueed_ret);
+}
+
+void QAccessible__State_setMarqueed(QAccessible__State* self, unsigned long long marqueed) {
+	self->marqueed = static_cast<quint64>(marqueed);
+}
+
+unsigned long long QAccessible__State_animated(const QAccessible__State* self) {
+	quint64 animated_ret = self->animated;
+	return static_cast<unsigned long long>(animated_ret);
+}
+
+void QAccessible__State_setAnimated(QAccessible__State* self, unsigned long long animated) {
+	self->animated = static_cast<quint64>(animated);
+}
+
+unsigned long long QAccessible__State_invisible(const QAccessible__State* self) {
+	quint64 invisible_ret = self->invisible;
+	return static_cast<unsigned long long>(invisible_ret);
+}
+
+void QAccessible__State_setInvisible(QAccessible__State* self, unsigned long long invisible) {
+	self->invisible = static_cast<quint64>(invisible);
+}
+
+unsigned long long QAccessible__State_offscreen(const QAccessible__State* self) {
+	quint64 offscreen_ret = self->offscreen;
+	return static_cast<unsigned long long>(offscreen_ret);
+}
+
+void QAccessible__State_setOffscreen(QAccessible__State* self, unsigned long long offscreen) {
+	self->offscreen = static_cast<quint64>(offscreen);
+}
+
+unsigned long long QAccessible__State_sizeable(const QAccessible__State* self) {
+	quint64 sizeable_ret = self->sizeable;
+	return static_cast<unsigned long long>(sizeable_ret);
+}
+
+void QAccessible__State_setSizeable(QAccessible__State* self, unsigned long long sizeable) {
+	self->sizeable = static_cast<quint64>(sizeable);
+}
+
+unsigned long long QAccessible__State_movable(const QAccessible__State* self) {
+	quint64 movable_ret = self->movable;
+	return static_cast<unsigned long long>(movable_ret);
+}
+
+void QAccessible__State_setMovable(QAccessible__State* self, unsigned long long movable) {
+	self->movable = static_cast<quint64>(movable);
+}
+
+unsigned long long QAccessible__State_selfVoicing(const QAccessible__State* self) {
+	quint64 selfVoicing_ret = self->selfVoicing;
+	return static_cast<unsigned long long>(selfVoicing_ret);
+}
+
+void QAccessible__State_setSelfVoicing(QAccessible__State* self, unsigned long long selfVoicing) {
+	self->selfVoicing = static_cast<quint64>(selfVoicing);
+}
+
+unsigned long long QAccessible__State_selectable(const QAccessible__State* self) {
+	quint64 selectable_ret = self->selectable;
+	return static_cast<unsigned long long>(selectable_ret);
+}
+
+void QAccessible__State_setSelectable(QAccessible__State* self, unsigned long long selectable) {
+	self->selectable = static_cast<quint64>(selectable);
+}
+
+unsigned long long QAccessible__State_linked(const QAccessible__State* self) {
+	quint64 linked_ret = self->linked;
+	return static_cast<unsigned long long>(linked_ret);
+}
+
+void QAccessible__State_setLinked(QAccessible__State* self, unsigned long long linked) {
+	self->linked = static_cast<quint64>(linked);
+}
+
+unsigned long long QAccessible__State_traversed(const QAccessible__State* self) {
+	quint64 traversed_ret = self->traversed;
+	return static_cast<unsigned long long>(traversed_ret);
+}
+
+void QAccessible__State_setTraversed(QAccessible__State* self, unsigned long long traversed) {
+	self->traversed = static_cast<quint64>(traversed);
+}
+
+unsigned long long QAccessible__State_multiSelectable(const QAccessible__State* self) {
+	quint64 multiSelectable_ret = self->multiSelectable;
+	return static_cast<unsigned long long>(multiSelectable_ret);
+}
+
+void QAccessible__State_setMultiSelectable(QAccessible__State* self, unsigned long long multiSelectable) {
+	self->multiSelectable = static_cast<quint64>(multiSelectable);
+}
+
+unsigned long long QAccessible__State_extSelectable(const QAccessible__State* self) {
+	quint64 extSelectable_ret = self->extSelectable;
+	return static_cast<unsigned long long>(extSelectable_ret);
+}
+
+void QAccessible__State_setExtSelectable(QAccessible__State* self, unsigned long long extSelectable) {
+	self->extSelectable = static_cast<quint64>(extSelectable);
+}
+
+unsigned long long QAccessible__State_passwordEdit(const QAccessible__State* self) {
+	quint64 passwordEdit_ret = self->passwordEdit;
+	return static_cast<unsigned long long>(passwordEdit_ret);
+}
+
+void QAccessible__State_setPasswordEdit(QAccessible__State* self, unsigned long long passwordEdit) {
+	self->passwordEdit = static_cast<quint64>(passwordEdit);
+}
+
+unsigned long long QAccessible__State_hasPopup(const QAccessible__State* self) {
+	quint64 hasPopup_ret = self->hasPopup;
+	return static_cast<unsigned long long>(hasPopup_ret);
+}
+
+void QAccessible__State_setHasPopup(QAccessible__State* self, unsigned long long hasPopup) {
+	self->hasPopup = static_cast<quint64>(hasPopup);
+}
+
+unsigned long long QAccessible__State_modal(const QAccessible__State* self) {
+	quint64 modal_ret = self->modal;
+	return static_cast<unsigned long long>(modal_ret);
+}
+
+void QAccessible__State_setModal(QAccessible__State* self, unsigned long long modal) {
+	self->modal = static_cast<quint64>(modal);
+}
+
+unsigned long long QAccessible__State_active(const QAccessible__State* self) {
+	quint64 active_ret = self->active;
+	return static_cast<unsigned long long>(active_ret);
+}
+
+void QAccessible__State_setActive(QAccessible__State* self, unsigned long long active) {
+	self->active = static_cast<quint64>(active);
+}
+
+unsigned long long QAccessible__State_invalid(const QAccessible__State* self) {
+	quint64 invalid_ret = self->invalid;
+	return static_cast<unsigned long long>(invalid_ret);
+}
+
+void QAccessible__State_setInvalid(QAccessible__State* self, unsigned long long invalid) {
+	self->invalid = static_cast<quint64>(invalid);
+}
+
+unsigned long long QAccessible__State_editable(const QAccessible__State* self) {
+	quint64 editable_ret = self->editable;
+	return static_cast<unsigned long long>(editable_ret);
+}
+
+void QAccessible__State_setEditable(QAccessible__State* self, unsigned long long editable) {
+	self->editable = static_cast<quint64>(editable);
+}
+
+unsigned long long QAccessible__State_multiLine(const QAccessible__State* self) {
+	quint64 multiLine_ret = self->multiLine;
+	return static_cast<unsigned long long>(multiLine_ret);
+}
+
+void QAccessible__State_setMultiLine(QAccessible__State* self, unsigned long long multiLine) {
+	self->multiLine = static_cast<quint64>(multiLine);
+}
+
+unsigned long long QAccessible__State_selectableText(const QAccessible__State* self) {
+	quint64 selectableText_ret = self->selectableText;
+	return static_cast<unsigned long long>(selectableText_ret);
+}
+
+void QAccessible__State_setSelectableText(QAccessible__State* self, unsigned long long selectableText) {
+	self->selectableText = static_cast<quint64>(selectableText);
+}
+
+unsigned long long QAccessible__State_supportsAutoCompletion(const QAccessible__State* self) {
+	quint64 supportsAutoCompletion_ret = self->supportsAutoCompletion;
+	return static_cast<unsigned long long>(supportsAutoCompletion_ret);
+}
+
+void QAccessible__State_setSupportsAutoCompletion(QAccessible__State* self, unsigned long long supportsAutoCompletion) {
+	self->supportsAutoCompletion = static_cast<quint64>(supportsAutoCompletion);
+}
+
+unsigned long long QAccessible__State_searchEdit(const QAccessible__State* self) {
+	quint64 searchEdit_ret = self->searchEdit;
+	return static_cast<unsigned long long>(searchEdit_ret);
+}
+
+void QAccessible__State_setSearchEdit(QAccessible__State* self, unsigned long long searchEdit) {
+	self->searchEdit = static_cast<quint64>(searchEdit);
+}
+
+void QAccessible__State_delete(QAccessible__State* self) {
+	delete self;
+}
+
+void QAccessible__ActivationObserver_accessibilityActiveChanged(QAccessible__ActivationObserver* self, bool active) {
+	self->accessibilityActiveChanged(active);
+}
+
+void QAccessible__ActivationObserver_operatorAssign(QAccessible__ActivationObserver* self, QAccessible__ActivationObserver* param1) {
+	self->operator=(*param1);
+}
+
+void QAccessible__ActivationObserver_delete(QAccessible__ActivationObserver* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessible_base.go

@@ -0,0 +1,728 @@
+package qt6
+
+/*
+
+#include "gen_qaccessible_base.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QAccessible__Event int
+
+const (
+	QAccessible__SoundPlayed                     QAccessible__Event = 1
+	QAccessible__Alert                           QAccessible__Event = 2
+	QAccessible__ForegroundChanged               QAccessible__Event = 3
+	QAccessible__MenuStart                       QAccessible__Event = 4
+	QAccessible__MenuEnd                         QAccessible__Event = 5
+	QAccessible__PopupMenuStart                  QAccessible__Event = 6
+	QAccessible__PopupMenuEnd                    QAccessible__Event = 7
+	QAccessible__ContextHelpStart                QAccessible__Event = 12
+	QAccessible__ContextHelpEnd                  QAccessible__Event = 13
+	QAccessible__DragDropStart                   QAccessible__Event = 14
+	QAccessible__DragDropEnd                     QAccessible__Event = 15
+	QAccessible__DialogStart                     QAccessible__Event = 16
+	QAccessible__DialogEnd                       QAccessible__Event = 17
+	QAccessible__ScrollingStart                  QAccessible__Event = 18
+	QAccessible__ScrollingEnd                    QAccessible__Event = 19
+	QAccessible__MenuCommand                     QAccessible__Event = 24
+	QAccessible__ActionChanged                   QAccessible__Event = 257
+	QAccessible__ActiveDescendantChanged         QAccessible__Event = 258
+	QAccessible__AttributeChanged                QAccessible__Event = 259
+	QAccessible__DocumentContentChanged          QAccessible__Event = 260
+	QAccessible__DocumentLoadComplete            QAccessible__Event = 261
+	QAccessible__DocumentLoadStopped             QAccessible__Event = 262
+	QAccessible__DocumentReload                  QAccessible__Event = 263
+	QAccessible__HyperlinkEndIndexChanged        QAccessible__Event = 264
+	QAccessible__HyperlinkNumberOfAnchorsChanged QAccessible__Event = 265
+	QAccessible__HyperlinkSelectedLinkChanged    QAccessible__Event = 266
+	QAccessible__HypertextLinkActivated          QAccessible__Event = 267
+	QAccessible__HypertextLinkSelected           QAccessible__Event = 268
+	QAccessible__HyperlinkStartIndexChanged      QAccessible__Event = 269
+	QAccessible__HypertextChanged                QAccessible__Event = 270
+	QAccessible__HypertextNLinksChanged          QAccessible__Event = 271
+	QAccessible__ObjectAttributeChanged          QAccessible__Event = 272
+	QAccessible__PageChanged                     QAccessible__Event = 273
+	QAccessible__SectionChanged                  QAccessible__Event = 274
+	QAccessible__TableCaptionChanged             QAccessible__Event = 275
+	QAccessible__TableColumnDescriptionChanged   QAccessible__Event = 276
+	QAccessible__TableColumnHeaderChanged        QAccessible__Event = 277
+	QAccessible__TableModelChanged               QAccessible__Event = 278
+	QAccessible__TableRowDescriptionChanged      QAccessible__Event = 279
+	QAccessible__TableRowHeaderChanged           QAccessible__Event = 280
+	QAccessible__TableSummaryChanged             QAccessible__Event = 281
+	QAccessible__TextAttributeChanged            QAccessible__Event = 282
+	QAccessible__TextCaretMoved                  QAccessible__Event = 283
+	QAccessible__TextColumnChanged               QAccessible__Event = 285
+	QAccessible__TextInserted                    QAccessible__Event = 286
+	QAccessible__TextRemoved                     QAccessible__Event = 287
+	QAccessible__TextUpdated                     QAccessible__Event = 288
+	QAccessible__TextSelectionChanged            QAccessible__Event = 289
+	QAccessible__VisibleDataChanged              QAccessible__Event = 290
+	QAccessible__ObjectCreated                   QAccessible__Event = 32768
+	QAccessible__ObjectDestroyed                 QAccessible__Event = 32769
+	QAccessible__ObjectShow                      QAccessible__Event = 32770
+	QAccessible__ObjectHide                      QAccessible__Event = 32771
+	QAccessible__ObjectReorder                   QAccessible__Event = 32772
+	QAccessible__Focus                           QAccessible__Event = 32773
+	QAccessible__Selection                       QAccessible__Event = 32774
+	QAccessible__SelectionAdd                    QAccessible__Event = 32775
+	QAccessible__SelectionRemove                 QAccessible__Event = 32776
+	QAccessible__SelectionWithin                 QAccessible__Event = 32777
+	QAccessible__StateChanged                    QAccessible__Event = 32778
+	QAccessible__LocationChanged                 QAccessible__Event = 32779
+	QAccessible__NameChanged                     QAccessible__Event = 32780
+	QAccessible__DescriptionChanged              QAccessible__Event = 32781
+	QAccessible__ValueChanged                    QAccessible__Event = 32782
+	QAccessible__ParentChanged                   QAccessible__Event = 32783
+	QAccessible__HelpChanged                     QAccessible__Event = 32928
+	QAccessible__DefaultActionChanged            QAccessible__Event = 32944
+	QAccessible__AcceleratorChanged              QAccessible__Event = 32960
+	QAccessible__InvalidEvent                    QAccessible__Event = 32961
+)
+
+type QAccessible__Role int
+
+const (
+	QAccessible__NoRole               QAccessible__Role = 0
+	QAccessible__TitleBar             QAccessible__Role = 1
+	QAccessible__MenuBar              QAccessible__Role = 2
+	QAccessible__ScrollBar            QAccessible__Role = 3
+	QAccessible__Grip                 QAccessible__Role = 4
+	QAccessible__Sound                QAccessible__Role = 5
+	QAccessible__Cursor               QAccessible__Role = 6
+	QAccessible__Caret                QAccessible__Role = 7
+	QAccessible__AlertMessage         QAccessible__Role = 8
+	QAccessible__Window               QAccessible__Role = 9
+	QAccessible__Client               QAccessible__Role = 10
+	QAccessible__PopupMenu            QAccessible__Role = 11
+	QAccessible__MenuItem             QAccessible__Role = 12
+	QAccessible__ToolTip              QAccessible__Role = 13
+	QAccessible__Application          QAccessible__Role = 14
+	QAccessible__Document             QAccessible__Role = 15
+	QAccessible__Pane                 QAccessible__Role = 16
+	QAccessible__Chart                QAccessible__Role = 17
+	QAccessible__Dialog               QAccessible__Role = 18
+	QAccessible__Border               QAccessible__Role = 19
+	QAccessible__Grouping             QAccessible__Role = 20
+	QAccessible__Separator            QAccessible__Role = 21
+	QAccessible__ToolBar              QAccessible__Role = 22
+	QAccessible__StatusBar            QAccessible__Role = 23
+	QAccessible__Table                QAccessible__Role = 24
+	QAccessible__ColumnHeader         QAccessible__Role = 25
+	QAccessible__RowHeader            QAccessible__Role = 26
+	QAccessible__Column               QAccessible__Role = 27
+	QAccessible__Row                  QAccessible__Role = 28
+	QAccessible__Cell                 QAccessible__Role = 29
+	QAccessible__Link                 QAccessible__Role = 30
+	QAccessible__HelpBalloon          QAccessible__Role = 31
+	QAccessible__Assistant            QAccessible__Role = 32
+	QAccessible__List                 QAccessible__Role = 33
+	QAccessible__ListItem             QAccessible__Role = 34
+	QAccessible__Tree                 QAccessible__Role = 35
+	QAccessible__TreeItem             QAccessible__Role = 36
+	QAccessible__PageTab              QAccessible__Role = 37
+	QAccessible__PropertyPage         QAccessible__Role = 38
+	QAccessible__Indicator            QAccessible__Role = 39
+	QAccessible__Graphic              QAccessible__Role = 40
+	QAccessible__StaticText           QAccessible__Role = 41
+	QAccessible__EditableText         QAccessible__Role = 42
+	QAccessible__Button               QAccessible__Role = 43
+	QAccessible__PushButton           QAccessible__Role = 43
+	QAccessible__CheckBox             QAccessible__Role = 44
+	QAccessible__RadioButton          QAccessible__Role = 45
+	QAccessible__ComboBox             QAccessible__Role = 46
+	QAccessible__ProgressBar          QAccessible__Role = 48
+	QAccessible__Dial                 QAccessible__Role = 49
+	QAccessible__HotkeyField          QAccessible__Role = 50
+	QAccessible__Slider               QAccessible__Role = 51
+	QAccessible__SpinBox              QAccessible__Role = 52
+	QAccessible__Canvas               QAccessible__Role = 53
+	QAccessible__Animation            QAccessible__Role = 54
+	QAccessible__Equation             QAccessible__Role = 55
+	QAccessible__ButtonDropDown       QAccessible__Role = 56
+	QAccessible__ButtonMenu           QAccessible__Role = 57
+	QAccessible__ButtonDropGrid       QAccessible__Role = 58
+	QAccessible__Whitespace           QAccessible__Role = 59
+	QAccessible__PageTabList          QAccessible__Role = 60
+	QAccessible__Clock                QAccessible__Role = 61
+	QAccessible__Splitter             QAccessible__Role = 62
+	QAccessible__LayeredPane          QAccessible__Role = 128
+	QAccessible__Terminal             QAccessible__Role = 129
+	QAccessible__Desktop              QAccessible__Role = 130
+	QAccessible__Paragraph            QAccessible__Role = 131
+	QAccessible__WebDocument          QAccessible__Role = 132
+	QAccessible__Section              QAccessible__Role = 133
+	QAccessible__Notification         QAccessible__Role = 134
+	QAccessible__ColorChooser         QAccessible__Role = 1028
+	QAccessible__Footer               QAccessible__Role = 1038
+	QAccessible__Form                 QAccessible__Role = 1040
+	QAccessible__Heading              QAccessible__Role = 1044
+	QAccessible__Note                 QAccessible__Role = 1051
+	QAccessible__ComplementaryContent QAccessible__Role = 1068
+	QAccessible__UserRole             QAccessible__Role = 65535
+)
+
+type QAccessible__Text int
+
+const (
+	QAccessible__Name             QAccessible__Text = 0
+	QAccessible__Description      QAccessible__Text = 1
+	QAccessible__Value            QAccessible__Text = 2
+	QAccessible__Help             QAccessible__Text = 3
+	QAccessible__Accelerator      QAccessible__Text = 4
+	QAccessible__DebugDescription QAccessible__Text = 5
+	QAccessible__UserText         QAccessible__Text = 65535
+)
+
+type QAccessible__RelationFlag int
+
+const (
+	QAccessible__Label      QAccessible__RelationFlag = 1
+	QAccessible__Labelled   QAccessible__RelationFlag = 2
+	QAccessible__Controller QAccessible__RelationFlag = 4
+	QAccessible__Controlled QAccessible__RelationFlag = 8
+)
+
+type QAccessible__InterfaceType int
+
+const (
+	QAccessible__TextInterface         QAccessible__InterfaceType = 0
+	QAccessible__EditableTextInterface QAccessible__InterfaceType = 1
+	QAccessible__ValueInterface        QAccessible__InterfaceType = 2
+	QAccessible__ActionInterface       QAccessible__InterfaceType = 3
+	QAccessible__ImageInterface        QAccessible__InterfaceType = 4
+	QAccessible__TableInterface        QAccessible__InterfaceType = 5
+	QAccessible__TableCellInterface    QAccessible__InterfaceType = 6
+	QAccessible__HyperlinkInterface    QAccessible__InterfaceType = 7
+)
+
+type QAccessible__TextBoundaryType int
+
+const (
+	QAccessible__CharBoundary      QAccessible__TextBoundaryType = 0
+	QAccessible__WordBoundary      QAccessible__TextBoundaryType = 1
+	QAccessible__SentenceBoundary  QAccessible__TextBoundaryType = 2
+	QAccessible__ParagraphBoundary QAccessible__TextBoundaryType = 3
+	QAccessible__LineBoundary      QAccessible__TextBoundaryType = 4
+	QAccessible__NoBoundary        QAccessible__TextBoundaryType = 5
+)
+
+type QAccessible struct {
+	h *C.QAccessible
+}
+
+func (this *QAccessible) cPointer() *C.QAccessible {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessible) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessible constructs the type using only CGO pointers.
+func newQAccessible(h *C.QAccessible) *QAccessible {
+	if h == nil {
+		return nil
+	}
+
+	return &QAccessible{h: h}
+}
+
+// UnsafeNewQAccessible constructs the type using only unsafe pointers.
+func UnsafeNewQAccessible(h unsafe.Pointer) *QAccessible {
+	return newQAccessible((*C.QAccessible)(h))
+}
+
+func QAccessible_InstallActivationObserver(param1 *QAccessible__ActivationObserver) {
+	C.QAccessible_installActivationObserver(param1.cPointer())
+}
+
+func QAccessible_RemoveActivationObserver(param1 *QAccessible__ActivationObserver) {
+	C.QAccessible_removeActivationObserver(param1.cPointer())
+}
+
+func QAccessible_QueryAccessibleInterface(param1 *QObject) *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessible_queryAccessibleInterface(param1.cPointer()))
+}
+
+func QAccessible_UniqueId(iface *QAccessibleInterface) uint {
+	return (uint)(C.QAccessible_uniqueId(iface.cPointer()))
+}
+
+func QAccessible_AccessibleInterface(uniqueId uint) *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessible_accessibleInterface((C.uint)(uniqueId)))
+}
+
+func QAccessible_RegisterAccessibleInterface(iface *QAccessibleInterface) uint {
+	return (uint)(C.QAccessible_registerAccessibleInterface(iface.cPointer()))
+}
+
+func QAccessible_DeleteAccessibleInterface(uniqueId uint) {
+	C.QAccessible_deleteAccessibleInterface((C.uint)(uniqueId))
+}
+
+func QAccessible_UpdateAccessibility(event *QAccessibleEvent) {
+	C.QAccessible_updateAccessibility(event.cPointer())
+}
+
+func QAccessible_IsActive() bool {
+	return (bool)(C.QAccessible_isActive())
+}
+
+func QAccessible_SetActive(active bool) {
+	C.QAccessible_setActive((C.bool)(active))
+}
+
+func QAccessible_SetRootObject(object *QObject) {
+	C.QAccessible_setRootObject(object.cPointer())
+}
+
+func QAccessible_Cleanup() {
+	C.QAccessible_cleanup()
+}
+
+func QAccessible_QAccessibleTextBoundaryHelper(cursor *QTextCursor, boundaryType QAccessible__TextBoundaryType) struct {
+	First  int
+	Second int
+} {
+	var _mm C.struct_miqt_map = C.QAccessible_qAccessibleTextBoundaryHelper(cursor.cPointer(), (C.int)(boundaryType))
+	_First_CArray := (*[0xffff]C.int)(unsafe.Pointer(_mm.keys))
+	_Second_CArray := (*[0xffff]C.int)(unsafe.Pointer(_mm.values))
+	_entry_First := (int)(_First_CArray[0])
+
+	_entry_Second := (int)(_Second_CArray[0])
+
+	return struct {
+		First  int
+		Second int
+	}{First: _entry_First, Second: _entry_Second}
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessible) Delete() {
+	C.QAccessible_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessible) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessible) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QAccessible__State struct {
+	h *C.QAccessible__State
+}
+
+func (this *QAccessible__State) cPointer() *C.QAccessible__State {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessible__State) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessible__State constructs the type using only CGO pointers.
+func newQAccessible__State(h *C.QAccessible__State) *QAccessible__State {
+	if h == nil {
+		return nil
+	}
+
+	return &QAccessible__State{h: h}
+}
+
+// UnsafeNewQAccessible__State constructs the type using only unsafe pointers.
+func UnsafeNewQAccessible__State(h unsafe.Pointer) *QAccessible__State {
+	return newQAccessible__State((*C.QAccessible__State)(h))
+}
+
+// NewQAccessible__State constructs a new QAccessible::State object.
+func NewQAccessible__State() *QAccessible__State {
+
+	return newQAccessible__State(C.QAccessible__State_new())
+}
+
+func (this *QAccessible__State) Disabled() uint64 {
+	return (uint64)(C.QAccessible__State_disabled(this.h))
+}
+
+func (this *QAccessible__State) SetDisabled(disabled uint64) {
+	C.QAccessible__State_setDisabled(this.h, (C.ulonglong)(disabled))
+}
+
+func (this *QAccessible__State) Selected() uint64 {
+	return (uint64)(C.QAccessible__State_selected(this.h))
+}
+
+func (this *QAccessible__State) SetSelected(selected uint64) {
+	C.QAccessible__State_setSelected(this.h, (C.ulonglong)(selected))
+}
+
+func (this *QAccessible__State) Focusable() uint64 {
+	return (uint64)(C.QAccessible__State_focusable(this.h))
+}
+
+func (this *QAccessible__State) SetFocusable(focusable uint64) {
+	C.QAccessible__State_setFocusable(this.h, (C.ulonglong)(focusable))
+}
+
+func (this *QAccessible__State) Focused() uint64 {
+	return (uint64)(C.QAccessible__State_focused(this.h))
+}
+
+func (this *QAccessible__State) SetFocused(focused uint64) {
+	C.QAccessible__State_setFocused(this.h, (C.ulonglong)(focused))
+}
+
+func (this *QAccessible__State) Pressed() uint64 {
+	return (uint64)(C.QAccessible__State_pressed(this.h))
+}
+
+func (this *QAccessible__State) SetPressed(pressed uint64) {
+	C.QAccessible__State_setPressed(this.h, (C.ulonglong)(pressed))
+}
+
+func (this *QAccessible__State) Checkable() uint64 {
+	return (uint64)(C.QAccessible__State_checkable(this.h))
+}
+
+func (this *QAccessible__State) SetCheckable(checkable uint64) {
+	C.QAccessible__State_setCheckable(this.h, (C.ulonglong)(checkable))
+}
+
+func (this *QAccessible__State) Checked() uint64 {
+	return (uint64)(C.QAccessible__State_checked(this.h))
+}
+
+func (this *QAccessible__State) SetChecked(checked uint64) {
+	C.QAccessible__State_setChecked(this.h, (C.ulonglong)(checked))
+}
+
+func (this *QAccessible__State) CheckStateMixed() uint64 {
+	return (uint64)(C.QAccessible__State_checkStateMixed(this.h))
+}
+
+func (this *QAccessible__State) SetCheckStateMixed(checkStateMixed uint64) {
+	C.QAccessible__State_setCheckStateMixed(this.h, (C.ulonglong)(checkStateMixed))
+}
+
+func (this *QAccessible__State) ReadOnly() uint64 {
+	return (uint64)(C.QAccessible__State_readOnly(this.h))
+}
+
+func (this *QAccessible__State) SetReadOnly(readOnly uint64) {
+	C.QAccessible__State_setReadOnly(this.h, (C.ulonglong)(readOnly))
+}
+
+func (this *QAccessible__State) HotTracked() uint64 {
+	return (uint64)(C.QAccessible__State_hotTracked(this.h))
+}
+
+func (this *QAccessible__State) SetHotTracked(hotTracked uint64) {
+	C.QAccessible__State_setHotTracked(this.h, (C.ulonglong)(hotTracked))
+}
+
+func (this *QAccessible__State) DefaultButton() uint64 {
+	return (uint64)(C.QAccessible__State_defaultButton(this.h))
+}
+
+func (this *QAccessible__State) SetDefaultButton(defaultButton uint64) {
+	C.QAccessible__State_setDefaultButton(this.h, (C.ulonglong)(defaultButton))
+}
+
+func (this *QAccessible__State) Expanded() uint64 {
+	return (uint64)(C.QAccessible__State_expanded(this.h))
+}
+
+func (this *QAccessible__State) SetExpanded(expanded uint64) {
+	C.QAccessible__State_setExpanded(this.h, (C.ulonglong)(expanded))
+}
+
+func (this *QAccessible__State) Collapsed() uint64 {
+	return (uint64)(C.QAccessible__State_collapsed(this.h))
+}
+
+func (this *QAccessible__State) SetCollapsed(collapsed uint64) {
+	C.QAccessible__State_setCollapsed(this.h, (C.ulonglong)(collapsed))
+}
+
+func (this *QAccessible__State) Busy() uint64 {
+	return (uint64)(C.QAccessible__State_busy(this.h))
+}
+
+func (this *QAccessible__State) SetBusy(busy uint64) {
+	C.QAccessible__State_setBusy(this.h, (C.ulonglong)(busy))
+}
+
+func (this *QAccessible__State) Expandable() uint64 {
+	return (uint64)(C.QAccessible__State_expandable(this.h))
+}
+
+func (this *QAccessible__State) SetExpandable(expandable uint64) {
+	C.QAccessible__State_setExpandable(this.h, (C.ulonglong)(expandable))
+}
+
+func (this *QAccessible__State) Marqueed() uint64 {
+	return (uint64)(C.QAccessible__State_marqueed(this.h))
+}
+
+func (this *QAccessible__State) SetMarqueed(marqueed uint64) {
+	C.QAccessible__State_setMarqueed(this.h, (C.ulonglong)(marqueed))
+}
+
+func (this *QAccessible__State) Animated() uint64 {
+	return (uint64)(C.QAccessible__State_animated(this.h))
+}
+
+func (this *QAccessible__State) SetAnimated(animated uint64) {
+	C.QAccessible__State_setAnimated(this.h, (C.ulonglong)(animated))
+}
+
+func (this *QAccessible__State) Invisible() uint64 {
+	return (uint64)(C.QAccessible__State_invisible(this.h))
+}
+
+func (this *QAccessible__State) SetInvisible(invisible uint64) {
+	C.QAccessible__State_setInvisible(this.h, (C.ulonglong)(invisible))
+}
+
+func (this *QAccessible__State) Offscreen() uint64 {
+	return (uint64)(C.QAccessible__State_offscreen(this.h))
+}
+
+func (this *QAccessible__State) SetOffscreen(offscreen uint64) {
+	C.QAccessible__State_setOffscreen(this.h, (C.ulonglong)(offscreen))
+}
+
+func (this *QAccessible__State) Sizeable() uint64 {
+	return (uint64)(C.QAccessible__State_sizeable(this.h))
+}
+
+func (this *QAccessible__State) SetSizeable(sizeable uint64) {
+	C.QAccessible__State_setSizeable(this.h, (C.ulonglong)(sizeable))
+}
+
+func (this *QAccessible__State) Movable() uint64 {
+	return (uint64)(C.QAccessible__State_movable(this.h))
+}
+
+func (this *QAccessible__State) SetMovable(movable uint64) {
+	C.QAccessible__State_setMovable(this.h, (C.ulonglong)(movable))
+}
+
+func (this *QAccessible__State) SelfVoicing() uint64 {
+	return (uint64)(C.QAccessible__State_selfVoicing(this.h))
+}
+
+func (this *QAccessible__State) SetSelfVoicing(selfVoicing uint64) {
+	C.QAccessible__State_setSelfVoicing(this.h, (C.ulonglong)(selfVoicing))
+}
+
+func (this *QAccessible__State) Selectable() uint64 {
+	return (uint64)(C.QAccessible__State_selectable(this.h))
+}
+
+func (this *QAccessible__State) SetSelectable(selectable uint64) {
+	C.QAccessible__State_setSelectable(this.h, (C.ulonglong)(selectable))
+}
+
+func (this *QAccessible__State) Linked() uint64 {
+	return (uint64)(C.QAccessible__State_linked(this.h))
+}
+
+func (this *QAccessible__State) SetLinked(linked uint64) {
+	C.QAccessible__State_setLinked(this.h, (C.ulonglong)(linked))
+}
+
+func (this *QAccessible__State) Traversed() uint64 {
+	return (uint64)(C.QAccessible__State_traversed(this.h))
+}
+
+func (this *QAccessible__State) SetTraversed(traversed uint64) {
+	C.QAccessible__State_setTraversed(this.h, (C.ulonglong)(traversed))
+}
+
+func (this *QAccessible__State) MultiSelectable() uint64 {
+	return (uint64)(C.QAccessible__State_multiSelectable(this.h))
+}
+
+func (this *QAccessible__State) SetMultiSelectable(multiSelectable uint64) {
+	C.QAccessible__State_setMultiSelectable(this.h, (C.ulonglong)(multiSelectable))
+}
+
+func (this *QAccessible__State) ExtSelectable() uint64 {
+	return (uint64)(C.QAccessible__State_extSelectable(this.h))
+}
+
+func (this *QAccessible__State) SetExtSelectable(extSelectable uint64) {
+	C.QAccessible__State_setExtSelectable(this.h, (C.ulonglong)(extSelectable))
+}
+
+func (this *QAccessible__State) PasswordEdit() uint64 {
+	return (uint64)(C.QAccessible__State_passwordEdit(this.h))
+}
+
+func (this *QAccessible__State) SetPasswordEdit(passwordEdit uint64) {
+	C.QAccessible__State_setPasswordEdit(this.h, (C.ulonglong)(passwordEdit))
+}
+
+func (this *QAccessible__State) HasPopup() uint64 {
+	return (uint64)(C.QAccessible__State_hasPopup(this.h))
+}
+
+func (this *QAccessible__State) SetHasPopup(hasPopup uint64) {
+	C.QAccessible__State_setHasPopup(this.h, (C.ulonglong)(hasPopup))
+}
+
+func (this *QAccessible__State) Modal() uint64 {
+	return (uint64)(C.QAccessible__State_modal(this.h))
+}
+
+func (this *QAccessible__State) SetModal(modal uint64) {
+	C.QAccessible__State_setModal(this.h, (C.ulonglong)(modal))
+}
+
+func (this *QAccessible__State) Active() uint64 {
+	return (uint64)(C.QAccessible__State_active(this.h))
+}
+
+func (this *QAccessible__State) SetActive(active uint64) {
+	C.QAccessible__State_setActive(this.h, (C.ulonglong)(active))
+}
+
+func (this *QAccessible__State) Invalid() uint64 {
+	return (uint64)(C.QAccessible__State_invalid(this.h))
+}
+
+func (this *QAccessible__State) SetInvalid(invalid uint64) {
+	C.QAccessible__State_setInvalid(this.h, (C.ulonglong)(invalid))
+}
+
+func (this *QAccessible__State) Editable() uint64 {
+	return (uint64)(C.QAccessible__State_editable(this.h))
+}
+
+func (this *QAccessible__State) SetEditable(editable uint64) {
+	C.QAccessible__State_setEditable(this.h, (C.ulonglong)(editable))
+}
+
+func (this *QAccessible__State) MultiLine() uint64 {
+	return (uint64)(C.QAccessible__State_multiLine(this.h))
+}
+
+func (this *QAccessible__State) SetMultiLine(multiLine uint64) {
+	C.QAccessible__State_setMultiLine(this.h, (C.ulonglong)(multiLine))
+}
+
+func (this *QAccessible__State) SelectableText() uint64 {
+	return (uint64)(C.QAccessible__State_selectableText(this.h))
+}
+
+func (this *QAccessible__State) SetSelectableText(selectableText uint64) {
+	C.QAccessible__State_setSelectableText(this.h, (C.ulonglong)(selectableText))
+}
+
+func (this *QAccessible__State) SupportsAutoCompletion() uint64 {
+	return (uint64)(C.QAccessible__State_supportsAutoCompletion(this.h))
+}
+
+func (this *QAccessible__State) SetSupportsAutoCompletion(supportsAutoCompletion uint64) {
+	C.QAccessible__State_setSupportsAutoCompletion(this.h, (C.ulonglong)(supportsAutoCompletion))
+}
+
+func (this *QAccessible__State) SearchEdit() uint64 {
+	return (uint64)(C.QAccessible__State_searchEdit(this.h))
+}
+
+func (this *QAccessible__State) SetSearchEdit(searchEdit uint64) {
+	C.QAccessible__State_setSearchEdit(this.h, (C.ulonglong)(searchEdit))
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessible__State) Delete() {
+	C.QAccessible__State_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessible__State) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessible__State) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QAccessible__ActivationObserver struct {
+	h *C.QAccessible__ActivationObserver
+}
+
+func (this *QAccessible__ActivationObserver) cPointer() *C.QAccessible__ActivationObserver {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessible__ActivationObserver) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessible__ActivationObserver constructs the type using only CGO pointers.
+func newQAccessible__ActivationObserver(h *C.QAccessible__ActivationObserver) *QAccessible__ActivationObserver {
+	if h == nil {
+		return nil
+	}
+
+	return &QAccessible__ActivationObserver{h: h}
+}
+
+// UnsafeNewQAccessible__ActivationObserver constructs the type using only unsafe pointers.
+func UnsafeNewQAccessible__ActivationObserver(h unsafe.Pointer) *QAccessible__ActivationObserver {
+	return newQAccessible__ActivationObserver((*C.QAccessible__ActivationObserver)(h))
+}
+
+func (this *QAccessible__ActivationObserver) AccessibilityActiveChanged(active bool) {
+	C.QAccessible__ActivationObserver_accessibilityActiveChanged(this.h, (C.bool)(active))
+}
+
+func (this *QAccessible__ActivationObserver) OperatorAssign(param1 *QAccessible__ActivationObserver) {
+	C.QAccessible__ActivationObserver_operatorAssign(this.h, param1.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessible__ActivationObserver) Delete() {
+	C.QAccessible__ActivationObserver_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessible__ActivationObserver) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessible__ActivationObserver) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qaccessible_base.h

@@ -0,0 +1,146 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLE_BASE_H
+#define MIQT_QT6_GEN_QACCESSIBLE_BASE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAccessible;
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__ActivationObserver)
+typedef QAccessible::ActivationObserver QAccessible__ActivationObserver;
+#else
+class QAccessible__ActivationObserver;
+#endif
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State)
+typedef QAccessible::State QAccessible__State;
+#else
+class QAccessible__State;
+#endif
+class QAccessibleEvent;
+class QAccessibleInterface;
+class QObject;
+class QTextCursor;
+#else
+typedef struct QAccessible QAccessible;
+typedef struct QAccessible__ActivationObserver QAccessible__ActivationObserver;
+typedef struct QAccessible__State QAccessible__State;
+typedef struct QAccessibleEvent QAccessibleEvent;
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QObject QObject;
+typedef struct QTextCursor QTextCursor;
+#endif
+
+void QAccessible_installActivationObserver(QAccessible__ActivationObserver* param1);
+void QAccessible_removeActivationObserver(QAccessible__ActivationObserver* param1);
+QAccessibleInterface* QAccessible_queryAccessibleInterface(QObject* param1);
+unsigned int QAccessible_uniqueId(QAccessibleInterface* iface);
+QAccessibleInterface* QAccessible_accessibleInterface(unsigned int uniqueId);
+unsigned int QAccessible_registerAccessibleInterface(QAccessibleInterface* iface);
+void QAccessible_deleteAccessibleInterface(unsigned int uniqueId);
+void QAccessible_updateAccessibility(QAccessibleEvent* event);
+bool QAccessible_isActive();
+void QAccessible_setActive(bool active);
+void QAccessible_setRootObject(QObject* object);
+void QAccessible_cleanup();
+struct miqt_map /* tuple of int and int */  QAccessible_qAccessibleTextBoundaryHelper(QTextCursor* cursor, int boundaryType);
+
+void QAccessible_delete(QAccessible* self);
+
+QAccessible__State* QAccessible__State_new();
+unsigned long long QAccessible__State_disabled(const QAccessible__State* self);
+void QAccessible__State_setDisabled(QAccessible__State* self, unsigned long long disabled);
+unsigned long long QAccessible__State_selected(const QAccessible__State* self);
+void QAccessible__State_setSelected(QAccessible__State* self, unsigned long long selected);
+unsigned long long QAccessible__State_focusable(const QAccessible__State* self);
+void QAccessible__State_setFocusable(QAccessible__State* self, unsigned long long focusable);
+unsigned long long QAccessible__State_focused(const QAccessible__State* self);
+void QAccessible__State_setFocused(QAccessible__State* self, unsigned long long focused);
+unsigned long long QAccessible__State_pressed(const QAccessible__State* self);
+void QAccessible__State_setPressed(QAccessible__State* self, unsigned long long pressed);
+unsigned long long QAccessible__State_checkable(const QAccessible__State* self);
+void QAccessible__State_setCheckable(QAccessible__State* self, unsigned long long checkable);
+unsigned long long QAccessible__State_checked(const QAccessible__State* self);
+void QAccessible__State_setChecked(QAccessible__State* self, unsigned long long checked);
+unsigned long long QAccessible__State_checkStateMixed(const QAccessible__State* self);
+void QAccessible__State_setCheckStateMixed(QAccessible__State* self, unsigned long long checkStateMixed);
+unsigned long long QAccessible__State_readOnly(const QAccessible__State* self);
+void QAccessible__State_setReadOnly(QAccessible__State* self, unsigned long long readOnly);
+unsigned long long QAccessible__State_hotTracked(const QAccessible__State* self);
+void QAccessible__State_setHotTracked(QAccessible__State* self, unsigned long long hotTracked);
+unsigned long long QAccessible__State_defaultButton(const QAccessible__State* self);
+void QAccessible__State_setDefaultButton(QAccessible__State* self, unsigned long long defaultButton);
+unsigned long long QAccessible__State_expanded(const QAccessible__State* self);
+void QAccessible__State_setExpanded(QAccessible__State* self, unsigned long long expanded);
+unsigned long long QAccessible__State_collapsed(const QAccessible__State* self);
+void QAccessible__State_setCollapsed(QAccessible__State* self, unsigned long long collapsed);
+unsigned long long QAccessible__State_busy(const QAccessible__State* self);
+void QAccessible__State_setBusy(QAccessible__State* self, unsigned long long busy);
+unsigned long long QAccessible__State_expandable(const QAccessible__State* self);
+void QAccessible__State_setExpandable(QAccessible__State* self, unsigned long long expandable);
+unsigned long long QAccessible__State_marqueed(const QAccessible__State* self);
+void QAccessible__State_setMarqueed(QAccessible__State* self, unsigned long long marqueed);
+unsigned long long QAccessible__State_animated(const QAccessible__State* self);
+void QAccessible__State_setAnimated(QAccessible__State* self, unsigned long long animated);
+unsigned long long QAccessible__State_invisible(const QAccessible__State* self);
+void QAccessible__State_setInvisible(QAccessible__State* self, unsigned long long invisible);
+unsigned long long QAccessible__State_offscreen(const QAccessible__State* self);
+void QAccessible__State_setOffscreen(QAccessible__State* self, unsigned long long offscreen);
+unsigned long long QAccessible__State_sizeable(const QAccessible__State* self);
+void QAccessible__State_setSizeable(QAccessible__State* self, unsigned long long sizeable);
+unsigned long long QAccessible__State_movable(const QAccessible__State* self);
+void QAccessible__State_setMovable(QAccessible__State* self, unsigned long long movable);
+unsigned long long QAccessible__State_selfVoicing(const QAccessible__State* self);
+void QAccessible__State_setSelfVoicing(QAccessible__State* self, unsigned long long selfVoicing);
+unsigned long long QAccessible__State_selectable(const QAccessible__State* self);
+void QAccessible__State_setSelectable(QAccessible__State* self, unsigned long long selectable);
+unsigned long long QAccessible__State_linked(const QAccessible__State* self);
+void QAccessible__State_setLinked(QAccessible__State* self, unsigned long long linked);
+unsigned long long QAccessible__State_traversed(const QAccessible__State* self);
+void QAccessible__State_setTraversed(QAccessible__State* self, unsigned long long traversed);
+unsigned long long QAccessible__State_multiSelectable(const QAccessible__State* self);
+void QAccessible__State_setMultiSelectable(QAccessible__State* self, unsigned long long multiSelectable);
+unsigned long long QAccessible__State_extSelectable(const QAccessible__State* self);
+void QAccessible__State_setExtSelectable(QAccessible__State* self, unsigned long long extSelectable);
+unsigned long long QAccessible__State_passwordEdit(const QAccessible__State* self);
+void QAccessible__State_setPasswordEdit(QAccessible__State* self, unsigned long long passwordEdit);
+unsigned long long QAccessible__State_hasPopup(const QAccessible__State* self);
+void QAccessible__State_setHasPopup(QAccessible__State* self, unsigned long long hasPopup);
+unsigned long long QAccessible__State_modal(const QAccessible__State* self);
+void QAccessible__State_setModal(QAccessible__State* self, unsigned long long modal);
+unsigned long long QAccessible__State_active(const QAccessible__State* self);
+void QAccessible__State_setActive(QAccessible__State* self, unsigned long long active);
+unsigned long long QAccessible__State_invalid(const QAccessible__State* self);
+void QAccessible__State_setInvalid(QAccessible__State* self, unsigned long long invalid);
+unsigned long long QAccessible__State_editable(const QAccessible__State* self);
+void QAccessible__State_setEditable(QAccessible__State* self, unsigned long long editable);
+unsigned long long QAccessible__State_multiLine(const QAccessible__State* self);
+void QAccessible__State_setMultiLine(QAccessible__State* self, unsigned long long multiLine);
+unsigned long long QAccessible__State_selectableText(const QAccessible__State* self);
+void QAccessible__State_setSelectableText(QAccessible__State* self, unsigned long long selectableText);
+unsigned long long QAccessible__State_supportsAutoCompletion(const QAccessible__State* self);
+void QAccessible__State_setSupportsAutoCompletion(QAccessible__State* self, unsigned long long supportsAutoCompletion);
+unsigned long long QAccessible__State_searchEdit(const QAccessible__State* self);
+void QAccessible__State_setSearchEdit(QAccessible__State* self, unsigned long long searchEdit);
+
+void QAccessible__State_delete(QAccessible__State* self);
+
+void QAccessible__ActivationObserver_accessibilityActiveChanged(QAccessible__ActivationObserver* self, bool active);
+void QAccessible__ActivationObserver_operatorAssign(QAccessible__ActivationObserver* self, QAccessible__ActivationObserver* param1);
+
+void QAccessible__ActivationObserver_delete(QAccessible__ActivationObserver* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessible_base_64bit.go

@@ -0,0 +1,7 @@
+//go:build !386 && !arm
+// +build !386,!arm
+
+package qt6
+
+const QAccessible__AllRelations QAccessible__RelationFlag = 4294967295
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblebridge.cpp

@@ -0,0 +1,420 @@
+#include <QAccessibleBridge>
+#include <QAccessibleBridgePlugin>
+#include <QAccessibleEvent>
+#include <QAccessibleInterface>
+#include <QChildEvent>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qaccessiblebridge.h>
+#include "gen_qaccessiblebridge.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+QAccessibleBridge* miqt_exec_callback_QAccessibleBridgePlugin_create(QAccessibleBridgePlugin*, intptr_t, struct miqt_string);
+bool miqt_exec_callback_QAccessibleBridgePlugin_event(QAccessibleBridgePlugin*, intptr_t, QEvent*);
+bool miqt_exec_callback_QAccessibleBridgePlugin_eventFilter(QAccessibleBridgePlugin*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAccessibleBridgePlugin_timerEvent(QAccessibleBridgePlugin*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAccessibleBridgePlugin_childEvent(QAccessibleBridgePlugin*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAccessibleBridgePlugin_customEvent(QAccessibleBridgePlugin*, intptr_t, QEvent*);
+void miqt_exec_callback_QAccessibleBridgePlugin_connectNotify(QAccessibleBridgePlugin*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAccessibleBridgePlugin_disconnectNotify(QAccessibleBridgePlugin*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+void QAccessibleBridge_setRootObject(QAccessibleBridge* self, QAccessibleInterface* rootObject) {
+	self->setRootObject(rootObject);
+}
+
+void QAccessibleBridge_notifyAccessibilityUpdate(QAccessibleBridge* self, QAccessibleEvent* event) {
+	self->notifyAccessibilityUpdate(event);
+}
+
+void QAccessibleBridge_operatorAssign(QAccessibleBridge* self, QAccessibleBridge* param1) {
+	self->operator=(*param1);
+}
+
+void QAccessibleBridge_delete(QAccessibleBridge* self) {
+	delete self;
+}
+
+class MiqtVirtualQAccessibleBridgePlugin final : public QAccessibleBridgePlugin {
+public:
+
+	MiqtVirtualQAccessibleBridgePlugin(): QAccessibleBridgePlugin() {}
+	MiqtVirtualQAccessibleBridgePlugin(QObject* parent): QAccessibleBridgePlugin(parent) {}
+
+	virtual ~MiqtVirtualQAccessibleBridgePlugin() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__create = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QAccessibleBridge* create(const QString& key) override {
+		if (handle__create == 0) {
+			return nullptr; // Pure virtual, there is no base we can call
+		}
+
+		const QString key_ret = key;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray key_b = key_ret.toUtf8();
+		struct miqt_string key_ms;
+		key_ms.len = key_b.length();
+		key_ms.data = static_cast<char*>(malloc(key_ms.len));
+		memcpy(key_ms.data, key_b.data(), key_ms.len);
+		struct miqt_string sigval1 = key_ms;
+		QAccessibleBridge* callback_return_value = miqt_exec_callback_QAccessibleBridgePlugin_create(this, handle__create, sigval1);
+		return 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 QAccessibleBridgePlugin::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QAccessibleBridgePlugin_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAccessibleBridgePlugin_virtualbase_event(void* self, QEvent* 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 QAccessibleBridgePlugin::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAccessibleBridgePlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAccessibleBridgePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QAccessibleBridgePlugin::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAccessibleBridgePlugin_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAccessibleBridgePlugin_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QAccessibleBridgePlugin::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAccessibleBridgePlugin_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAccessibleBridgePlugin_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QAccessibleBridgePlugin::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAccessibleBridgePlugin_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAccessibleBridgePlugin_virtualbase_customEvent(void* self, QEvent* 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) {
+			QAccessibleBridgePlugin::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAccessibleBridgePlugin_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAccessibleBridgePlugin_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QAccessibleBridgePlugin::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAccessibleBridgePlugin_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAccessibleBridgePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QAccessibleBridgePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAccessibleBridgePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAccessibleBridgePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAccessibleBridgePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAccessibleBridgePlugin* QAccessibleBridgePlugin_new() {
+	return new (std::nothrow) MiqtVirtualQAccessibleBridgePlugin();
+}
+
+QAccessibleBridgePlugin* QAccessibleBridgePlugin_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQAccessibleBridgePlugin(parent);
+}
+
+void QAccessibleBridgePlugin_virtbase(QAccessibleBridgePlugin* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAccessibleBridgePlugin_metaObject(const QAccessibleBridgePlugin* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAccessibleBridgePlugin_metacast(QAccessibleBridgePlugin* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAccessibleBridgePlugin_tr(const char* s) {
+	QString _ret = QAccessibleBridgePlugin::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAccessibleBridge* QAccessibleBridgePlugin_create(QAccessibleBridgePlugin* self, struct miqt_string key) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return self->create(key_QString);
+}
+
+struct miqt_string QAccessibleBridgePlugin_tr2(const char* s, const char* c) {
+	QString _ret = QAccessibleBridgePlugin::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAccessibleBridgePlugin_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAccessibleBridgePlugin::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QAccessibleBridgePlugin_override_virtual_create(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__create = slot;
+	return true;
+}
+
+bool QAccessibleBridgePlugin_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAccessibleBridgePlugin_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::event(event);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAccessibleBridgePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::eventFilter(watched, event);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAccessibleBridgePlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::timerEvent(event);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAccessibleBridgePlugin_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::childEvent(event);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAccessibleBridgePlugin_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::customEvent(event);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAccessibleBridgePlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::connectNotify(*signal);
+}
+
+bool QAccessibleBridgePlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAccessibleBridgePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAccessibleBridgePlugin*>(self)->QAccessibleBridgePlugin::disconnectNotify(*signal);
+}
+
+QObject* QAccessibleBridgePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAccessibleBridgePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAccessibleBridgePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAccessibleBridgePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAccessibleBridgePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessibleBridgePlugin*>( (QAccessibleBridgePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAccessibleBridgePlugin_delete(QAccessibleBridgePlugin* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblebridge.go

@@ -0,0 +1,455 @@
+package qt6
+
+/*
+
+#include "gen_qaccessiblebridge.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAccessibleBridge struct {
+	h *C.QAccessibleBridge
+}
+
+func (this *QAccessibleBridge) cPointer() *C.QAccessibleBridge {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessibleBridge) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessibleBridge constructs the type using only CGO pointers.
+func newQAccessibleBridge(h *C.QAccessibleBridge) *QAccessibleBridge {
+	if h == nil {
+		return nil
+	}
+
+	return &QAccessibleBridge{h: h}
+}
+
+// UnsafeNewQAccessibleBridge constructs the type using only unsafe pointers.
+func UnsafeNewQAccessibleBridge(h unsafe.Pointer) *QAccessibleBridge {
+	return newQAccessibleBridge((*C.QAccessibleBridge)(h))
+}
+
+func (this *QAccessibleBridge) SetRootObject(rootObject *QAccessibleInterface) {
+	C.QAccessibleBridge_setRootObject(this.h, rootObject.cPointer())
+}
+
+func (this *QAccessibleBridge) NotifyAccessibilityUpdate(event *QAccessibleEvent) {
+	C.QAccessibleBridge_notifyAccessibilityUpdate(this.h, event.cPointer())
+}
+
+func (this *QAccessibleBridge) OperatorAssign(param1 *QAccessibleBridge) {
+	C.QAccessibleBridge_operatorAssign(this.h, param1.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessibleBridge) Delete() {
+	C.QAccessibleBridge_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessibleBridge) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessibleBridge) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QAccessibleBridgePlugin struct {
+	h *C.QAccessibleBridgePlugin
+	*QObject
+}
+
+func (this *QAccessibleBridgePlugin) cPointer() *C.QAccessibleBridgePlugin {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessibleBridgePlugin) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessibleBridgePlugin constructs the type using only CGO pointers.
+func newQAccessibleBridgePlugin(h *C.QAccessibleBridgePlugin) *QAccessibleBridgePlugin {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QAccessibleBridgePlugin_virtbase(h, &outptr_QObject)
+
+	return &QAccessibleBridgePlugin{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQAccessibleBridgePlugin constructs the type using only unsafe pointers.
+func UnsafeNewQAccessibleBridgePlugin(h unsafe.Pointer) *QAccessibleBridgePlugin {
+	return newQAccessibleBridgePlugin((*C.QAccessibleBridgePlugin)(h))
+}
+
+// NewQAccessibleBridgePlugin constructs a new QAccessibleBridgePlugin object.
+func NewQAccessibleBridgePlugin() *QAccessibleBridgePlugin {
+
+	return newQAccessibleBridgePlugin(C.QAccessibleBridgePlugin_new())
+}
+
+// NewQAccessibleBridgePlugin2 constructs a new QAccessibleBridgePlugin object.
+func NewQAccessibleBridgePlugin2(parent *QObject) *QAccessibleBridgePlugin {
+
+	return newQAccessibleBridgePlugin(C.QAccessibleBridgePlugin_new2(parent.cPointer()))
+}
+
+func (this *QAccessibleBridgePlugin) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAccessibleBridgePlugin_metaObject(this.h))
+}
+
+func (this *QAccessibleBridgePlugin) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAccessibleBridgePlugin_metacast(this.h, param1_Cstring))
+}
+
+func QAccessibleBridgePlugin_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessibleBridgePlugin_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAccessibleBridgePlugin) Create(key string) *QAccessibleBridge {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	return newQAccessibleBridge(C.QAccessibleBridgePlugin_create(this.h, key_ms))
+}
+
+func QAccessibleBridgePlugin_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessibleBridgePlugin_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAccessibleBridgePlugin_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessibleBridgePlugin_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QAccessibleBridgePlugin that was directly constructed.
+func (this *QAccessibleBridgePlugin) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QAccessibleBridgePlugin_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QAccessibleBridgePlugin that was directly constructed.
+func (this *QAccessibleBridgePlugin) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAccessibleBridgePlugin_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QAccessibleBridgePlugin that was directly constructed.
+func (this *QAccessibleBridgePlugin) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAccessibleBridgePlugin_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QAccessibleBridgePlugin that was directly constructed.
+func (this *QAccessibleBridgePlugin) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QAccessibleBridgePlugin_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+func (this *QAccessibleBridgePlugin) OnCreate(slot func(key string) *QAccessibleBridge) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_create(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_create
+func miqt_exec_callback_QAccessibleBridgePlugin_create(self *C.QAccessibleBridgePlugin, cb C.intptr_t, key C.struct_miqt_string) *C.QAccessibleBridge {
+	gofunc, ok := cgo.Handle(cb).Value().(func(key string) *QAccessibleBridge)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var key_ms C.struct_miqt_string = key
+	key_ret := C.GoStringN(key_ms.data, C.int(int64(key_ms.len)))
+	C.free(unsafe.Pointer(key_ms.data))
+	slotval1 := key_ret
+
+	virtualReturn := gofunc(slotval1)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAccessibleBridgePlugin_virtualbase_event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAccessibleBridgePlugin) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_event
+func miqt_exec_callback_QAccessibleBridgePlugin_event(self *C.QAccessibleBridgePlugin, 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 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAccessibleBridgePlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAccessibleBridgePlugin) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_eventFilter
+func miqt_exec_callback_QAccessibleBridgePlugin_eventFilter(self *C.QAccessibleBridgePlugin, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAccessibleBridgePlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessibleBridgePlugin) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_timerEvent
+func miqt_exec_callback_QAccessibleBridgePlugin_timerEvent(self *C.QAccessibleBridgePlugin, 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 := newQTimerEvent(event)
+
+	gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAccessibleBridgePlugin_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessibleBridgePlugin) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_childEvent
+func miqt_exec_callback_QAccessibleBridgePlugin_childEvent(self *C.QAccessibleBridgePlugin, 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 := newQChildEvent(event)
+
+	gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAccessibleBridgePlugin_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessibleBridgePlugin) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_customEvent
+func miqt_exec_callback_QAccessibleBridgePlugin_customEvent(self *C.QAccessibleBridgePlugin, 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 := newQEvent(event)
+
+	gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAccessibleBridgePlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAccessibleBridgePlugin) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_connectNotify
+func miqt_exec_callback_QAccessibleBridgePlugin_connectNotify(self *C.QAccessibleBridgePlugin, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAccessibleBridgePlugin) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAccessibleBridgePlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAccessibleBridgePlugin) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAccessibleBridgePlugin_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessibleBridgePlugin_disconnectNotify
+func miqt_exec_callback_QAccessibleBridgePlugin_disconnectNotify(self *C.QAccessibleBridgePlugin, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAccessibleBridgePlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessibleBridgePlugin) Delete() {
+	C.QAccessibleBridgePlugin_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessibleBridgePlugin) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessibleBridgePlugin) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblebridge.h

@@ -0,0 +1,85 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLEBRIDGE_H
+#define MIQT_QT6_GEN_QACCESSIBLEBRIDGE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAccessibleBridge;
+class QAccessibleBridgePlugin;
+class QAccessibleEvent;
+class QAccessibleInterface;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+#else
+typedef struct QAccessibleBridge QAccessibleBridge;
+typedef struct QAccessibleBridgePlugin QAccessibleBridgePlugin;
+typedef struct QAccessibleEvent QAccessibleEvent;
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+void QAccessibleBridge_setRootObject(QAccessibleBridge* self, QAccessibleInterface* rootObject);
+void QAccessibleBridge_notifyAccessibilityUpdate(QAccessibleBridge* self, QAccessibleEvent* event);
+void QAccessibleBridge_operatorAssign(QAccessibleBridge* self, QAccessibleBridge* param1);
+
+void QAccessibleBridge_delete(QAccessibleBridge* self);
+
+QAccessibleBridgePlugin* QAccessibleBridgePlugin_new();
+QAccessibleBridgePlugin* QAccessibleBridgePlugin_new2(QObject* parent);
+void QAccessibleBridgePlugin_virtbase(QAccessibleBridgePlugin* src, QObject** outptr_QObject);
+QMetaObject* QAccessibleBridgePlugin_metaObject(const QAccessibleBridgePlugin* self);
+void* QAccessibleBridgePlugin_metacast(QAccessibleBridgePlugin* self, const char* param1);
+struct miqt_string QAccessibleBridgePlugin_tr(const char* s);
+QAccessibleBridge* QAccessibleBridgePlugin_create(QAccessibleBridgePlugin* self, struct miqt_string key);
+struct miqt_string QAccessibleBridgePlugin_tr2(const char* s, const char* c);
+struct miqt_string QAccessibleBridgePlugin_tr3(const char* s, const char* c, int n);
+
+bool QAccessibleBridgePlugin_override_virtual_create(void* self, intptr_t slot);
+QAccessibleBridge* QAccessibleBridgePlugin_virtualbase_create(void* self, struct miqt_string key);
+bool QAccessibleBridgePlugin_override_virtual_event(void* self, intptr_t slot);
+bool QAccessibleBridgePlugin_virtualbase_event(void* self, QEvent* event);
+bool QAccessibleBridgePlugin_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAccessibleBridgePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAccessibleBridgePlugin_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAccessibleBridgePlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAccessibleBridgePlugin_override_virtual_childEvent(void* self, intptr_t slot);
+void QAccessibleBridgePlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAccessibleBridgePlugin_override_virtual_customEvent(void* self, intptr_t slot);
+void QAccessibleBridgePlugin_virtualbase_customEvent(void* self, QEvent* event);
+bool QAccessibleBridgePlugin_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAccessibleBridgePlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAccessibleBridgePlugin_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAccessibleBridgePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAccessibleBridgePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAccessibleBridgePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAccessibleBridgePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAccessibleBridgePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAccessibleBridgePlugin_delete(QAccessibleBridgePlugin* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleobject.cpp

@@ -0,0 +1,102 @@
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State
+#include <QAccessibleApplication>
+#include <QAccessibleInterface>
+#include <QAccessibleObject>
+#include <QObject>
+#include <QRect>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QWindow>
+#include <qaccessibleobject.h>
+#include "gen_qaccessibleobject.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+void QAccessibleObject_virtbase(QAccessibleObject* src, QAccessibleInterface** outptr_QAccessibleInterface) {
+	*outptr_QAccessibleInterface = static_cast<QAccessibleInterface*>(src);
+}
+
+bool QAccessibleObject_isValid(const QAccessibleObject* self) {
+	return self->isValid();
+}
+
+QObject* QAccessibleObject_object(const QAccessibleObject* self) {
+	return self->object();
+}
+
+QRect* QAccessibleObject_rect(const QAccessibleObject* self) {
+	return new QRect(self->rect());
+}
+
+void QAccessibleObject_setText(QAccessibleObject* self, int t, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	self->setText(static_cast<QAccessible::Text>(t), text_QString);
+}
+
+QAccessibleInterface* QAccessibleObject_childAt(const QAccessibleObject* self, int x, int y) {
+	return self->childAt(static_cast<int>(x), static_cast<int>(y));
+}
+
+QAccessibleApplication* QAccessibleApplication_new() {
+	return new (std::nothrow) QAccessibleApplication();
+}
+
+void QAccessibleApplication_virtbase(QAccessibleApplication* src, QAccessibleObject** outptr_QAccessibleObject) {
+	*outptr_QAccessibleObject = static_cast<QAccessibleObject*>(src);
+}
+
+QWindow* QAccessibleApplication_window(const QAccessibleApplication* self) {
+	return self->window();
+}
+
+int QAccessibleApplication_childCount(const QAccessibleApplication* self) {
+	return self->childCount();
+}
+
+int QAccessibleApplication_indexOfChild(const QAccessibleApplication* self, QAccessibleInterface* param1) {
+	return self->indexOfChild(param1);
+}
+
+QAccessibleInterface* QAccessibleApplication_focusChild(const QAccessibleApplication* self) {
+	return self->focusChild();
+}
+
+QAccessibleInterface* QAccessibleApplication_parent(const QAccessibleApplication* self) {
+	return self->parent();
+}
+
+QAccessibleInterface* QAccessibleApplication_child(const QAccessibleApplication* self, int index) {
+	return self->child(static_cast<int>(index));
+}
+
+struct miqt_string QAccessibleApplication_text(const QAccessibleApplication* self, int t) {
+	QString _ret = self->text(static_cast<QAccessible::Text>(t));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QAccessibleApplication_role(const QAccessibleApplication* self) {
+	QAccessible::Role _ret = self->role();
+	return static_cast<int>(_ret);
+}
+
+QAccessible__State* QAccessibleApplication_state(const QAccessibleApplication* self) {
+	return new QAccessible::State(self->state());
+}
+
+void QAccessibleApplication_delete(QAccessibleApplication* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleobject.go

@@ -0,0 +1,173 @@
+package qt6
+
+/*
+
+#include "gen_qaccessibleobject.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QAccessibleObject struct {
+	h *C.QAccessibleObject
+	*QAccessibleInterface
+}
+
+func (this *QAccessibleObject) cPointer() *C.QAccessibleObject {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessibleObject) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessibleObject constructs the type using only CGO pointers.
+func newQAccessibleObject(h *C.QAccessibleObject) *QAccessibleObject {
+	if h == nil {
+		return nil
+	}
+	var outptr_QAccessibleInterface *C.QAccessibleInterface = nil
+	C.QAccessibleObject_virtbase(h, &outptr_QAccessibleInterface)
+
+	return &QAccessibleObject{h: h,
+		QAccessibleInterface: newQAccessibleInterface(outptr_QAccessibleInterface)}
+}
+
+// UnsafeNewQAccessibleObject constructs the type using only unsafe pointers.
+func UnsafeNewQAccessibleObject(h unsafe.Pointer) *QAccessibleObject {
+	return newQAccessibleObject((*C.QAccessibleObject)(h))
+}
+
+func (this *QAccessibleObject) IsValid() bool {
+	return (bool)(C.QAccessibleObject_isValid(this.h))
+}
+
+func (this *QAccessibleObject) Object() *QObject {
+	return newQObject(C.QAccessibleObject_object(this.h))
+}
+
+func (this *QAccessibleObject) Rect() *QRect {
+	_goptr := newQRect(C.QAccessibleObject_rect(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAccessibleObject) SetText(t QAccessible__Text, text string) {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+	C.QAccessibleObject_setText(this.h, (C.int)(t), text_ms)
+}
+
+func (this *QAccessibleObject) ChildAt(x int, y int) *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleObject_childAt(this.h, (C.int)(x), (C.int)(y)))
+}
+
+type QAccessibleApplication struct {
+	h *C.QAccessibleApplication
+	*QAccessibleObject
+}
+
+func (this *QAccessibleApplication) cPointer() *C.QAccessibleApplication {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessibleApplication) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessibleApplication constructs the type using only CGO pointers.
+func newQAccessibleApplication(h *C.QAccessibleApplication) *QAccessibleApplication {
+	if h == nil {
+		return nil
+	}
+	var outptr_QAccessibleObject *C.QAccessibleObject = nil
+	C.QAccessibleApplication_virtbase(h, &outptr_QAccessibleObject)
+
+	return &QAccessibleApplication{h: h,
+		QAccessibleObject: newQAccessibleObject(outptr_QAccessibleObject)}
+}
+
+// UnsafeNewQAccessibleApplication constructs the type using only unsafe pointers.
+func UnsafeNewQAccessibleApplication(h unsafe.Pointer) *QAccessibleApplication {
+	return newQAccessibleApplication((*C.QAccessibleApplication)(h))
+}
+
+// NewQAccessibleApplication constructs a new QAccessibleApplication object.
+func NewQAccessibleApplication() *QAccessibleApplication {
+
+	return newQAccessibleApplication(C.QAccessibleApplication_new())
+}
+
+func (this *QAccessibleApplication) Window() *QWindow {
+	return newQWindow(C.QAccessibleApplication_window(this.h))
+}
+
+func (this *QAccessibleApplication) ChildCount() int {
+	return (int)(C.QAccessibleApplication_childCount(this.h))
+}
+
+func (this *QAccessibleApplication) IndexOfChild(param1 *QAccessibleInterface) int {
+	return (int)(C.QAccessibleApplication_indexOfChild(this.h, param1.cPointer()))
+}
+
+func (this *QAccessibleApplication) FocusChild() *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleApplication_focusChild(this.h))
+}
+
+func (this *QAccessibleApplication) Parent() *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleApplication_parent(this.h))
+}
+
+func (this *QAccessibleApplication) Child(index int) *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleApplication_child(this.h, (C.int)(index)))
+}
+
+func (this *QAccessibleApplication) Text(t QAccessible__Text) string {
+	var _ms C.struct_miqt_string = C.QAccessibleApplication_text(this.h, (C.int)(t))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAccessibleApplication) Role() QAccessible__Role {
+	return (QAccessible__Role)(C.QAccessibleApplication_role(this.h))
+}
+
+func (this *QAccessibleApplication) State() *QAccessible__State {
+	_goptr := newQAccessible__State(C.QAccessibleApplication_state(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessibleApplication) Delete() {
+	C.QAccessibleApplication_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessibleApplication) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessibleApplication) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleobject.h

@@ -0,0 +1,65 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLEOBJECT_H
+#define MIQT_QT6_GEN_QACCESSIBLEOBJECT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State)
+typedef QAccessible::State QAccessible__State;
+#else
+class QAccessible__State;
+#endif
+class QAccessibleApplication;
+class QAccessibleInterface;
+class QAccessibleObject;
+class QObject;
+class QRect;
+class QWindow;
+#else
+typedef struct QAccessible__State QAccessible__State;
+typedef struct QAccessibleApplication QAccessibleApplication;
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QAccessibleObject QAccessibleObject;
+typedef struct QObject QObject;
+typedef struct QRect QRect;
+typedef struct QWindow QWindow;
+#endif
+
+void QAccessibleObject_virtbase(QAccessibleObject* src, QAccessibleInterface** outptr_QAccessibleInterface);
+bool QAccessibleObject_isValid(const QAccessibleObject* self);
+QObject* QAccessibleObject_object(const QAccessibleObject* self);
+QRect* QAccessibleObject_rect(const QAccessibleObject* self);
+void QAccessibleObject_setText(QAccessibleObject* self, int t, struct miqt_string text);
+QAccessibleInterface* QAccessibleObject_childAt(const QAccessibleObject* self, int x, int y);
+
+
+QAccessibleApplication* QAccessibleApplication_new();
+void QAccessibleApplication_virtbase(QAccessibleApplication* src, QAccessibleObject** outptr_QAccessibleObject);
+QWindow* QAccessibleApplication_window(const QAccessibleApplication* self);
+int QAccessibleApplication_childCount(const QAccessibleApplication* self);
+int QAccessibleApplication_indexOfChild(const QAccessibleApplication* self, QAccessibleInterface* param1);
+QAccessibleInterface* QAccessibleApplication_focusChild(const QAccessibleApplication* self);
+QAccessibleInterface* QAccessibleApplication_parent(const QAccessibleApplication* self);
+QAccessibleInterface* QAccessibleApplication_child(const QAccessibleApplication* self, int index);
+struct miqt_string QAccessibleApplication_text(const QAccessibleApplication* self, int t);
+int QAccessibleApplication_role(const QAccessibleApplication* self);
+QAccessible__State* QAccessibleApplication_state(const QAccessibleApplication* self);
+
+void QAccessibleApplication_delete(QAccessibleApplication* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleplugin.cpp

@@ -0,0 +1,403 @@
+#include <QAccessibleInterface>
+#include <QAccessiblePlugin>
+#include <QChildEvent>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qaccessibleplugin.h>
+#include "gen_qaccessibleplugin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+QAccessibleInterface* miqt_exec_callback_QAccessiblePlugin_create(QAccessiblePlugin*, intptr_t, struct miqt_string, QObject*);
+bool miqt_exec_callback_QAccessiblePlugin_event(QAccessiblePlugin*, intptr_t, QEvent*);
+bool miqt_exec_callback_QAccessiblePlugin_eventFilter(QAccessiblePlugin*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAccessiblePlugin_timerEvent(QAccessiblePlugin*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAccessiblePlugin_childEvent(QAccessiblePlugin*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAccessiblePlugin_customEvent(QAccessiblePlugin*, intptr_t, QEvent*);
+void miqt_exec_callback_QAccessiblePlugin_connectNotify(QAccessiblePlugin*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAccessiblePlugin_disconnectNotify(QAccessiblePlugin*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAccessiblePlugin final : public QAccessiblePlugin {
+public:
+
+	MiqtVirtualQAccessiblePlugin(): QAccessiblePlugin() {}
+	MiqtVirtualQAccessiblePlugin(QObject* parent): QAccessiblePlugin(parent) {}
+
+	virtual ~MiqtVirtualQAccessiblePlugin() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__create = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QAccessibleInterface* create(const QString& key, QObject* object) override {
+		if (handle__create == 0) {
+			return nullptr; // Pure virtual, there is no base we can call
+		}
+
+		const QString key_ret = key;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray key_b = key_ret.toUtf8();
+		struct miqt_string key_ms;
+		key_ms.len = key_b.length();
+		key_ms.data = static_cast<char*>(malloc(key_ms.len));
+		memcpy(key_ms.data, key_b.data(), key_ms.len);
+		struct miqt_string sigval1 = key_ms;
+		QObject* sigval2 = object;
+		QAccessibleInterface* callback_return_value = miqt_exec_callback_QAccessiblePlugin_create(this, handle__create, sigval1, sigval2);
+		return 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 QAccessiblePlugin::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QAccessiblePlugin_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAccessiblePlugin_virtualbase_event(void* self, QEvent* 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 QAccessiblePlugin::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAccessiblePlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAccessiblePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QAccessiblePlugin::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAccessiblePlugin_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAccessiblePlugin_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QAccessiblePlugin::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAccessiblePlugin_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAccessiblePlugin_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QAccessiblePlugin::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAccessiblePlugin_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAccessiblePlugin_virtualbase_customEvent(void* self, QEvent* 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) {
+			QAccessiblePlugin::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAccessiblePlugin_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAccessiblePlugin_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QAccessiblePlugin::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAccessiblePlugin_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAccessiblePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QAccessiblePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAccessiblePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAccessiblePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAccessiblePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAccessiblePlugin* QAccessiblePlugin_new() {
+	return new (std::nothrow) MiqtVirtualQAccessiblePlugin();
+}
+
+QAccessiblePlugin* QAccessiblePlugin_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQAccessiblePlugin(parent);
+}
+
+void QAccessiblePlugin_virtbase(QAccessiblePlugin* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAccessiblePlugin_metaObject(const QAccessiblePlugin* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAccessiblePlugin_metacast(QAccessiblePlugin* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAccessiblePlugin_tr(const char* s) {
+	QString _ret = QAccessiblePlugin::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAccessibleInterface* QAccessiblePlugin_create(QAccessiblePlugin* self, struct miqt_string key, QObject* object) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return self->create(key_QString, object);
+}
+
+struct miqt_string QAccessiblePlugin_tr2(const char* s, const char* c) {
+	QString _ret = QAccessiblePlugin::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAccessiblePlugin_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAccessiblePlugin::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QAccessiblePlugin_override_virtual_create(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__create = slot;
+	return true;
+}
+
+bool QAccessiblePlugin_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAccessiblePlugin_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::event(event);
+}
+
+bool QAccessiblePlugin_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAccessiblePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::eventFilter(watched, event);
+}
+
+bool QAccessiblePlugin_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAccessiblePlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::timerEvent(event);
+}
+
+bool QAccessiblePlugin_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAccessiblePlugin_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::childEvent(event);
+}
+
+bool QAccessiblePlugin_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAccessiblePlugin_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::customEvent(event);
+}
+
+bool QAccessiblePlugin_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAccessiblePlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::connectNotify(*signal);
+}
+
+bool QAccessiblePlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAccessiblePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAccessiblePlugin*>(self)->QAccessiblePlugin::disconnectNotify(*signal);
+}
+
+QObject* QAccessiblePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAccessiblePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAccessiblePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAccessiblePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAccessiblePlugin* self_cast = dynamic_cast<MiqtVirtualQAccessiblePlugin*>( (QAccessiblePlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAccessiblePlugin_delete(QAccessiblePlugin* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleplugin.go

@@ -0,0 +1,398 @@
+package qt6
+
+/*
+
+#include "gen_qaccessibleplugin.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAccessiblePlugin struct {
+	h *C.QAccessiblePlugin
+	*QObject
+}
+
+func (this *QAccessiblePlugin) cPointer() *C.QAccessiblePlugin {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessiblePlugin) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessiblePlugin constructs the type using only CGO pointers.
+func newQAccessiblePlugin(h *C.QAccessiblePlugin) *QAccessiblePlugin {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QAccessiblePlugin_virtbase(h, &outptr_QObject)
+
+	return &QAccessiblePlugin{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQAccessiblePlugin constructs the type using only unsafe pointers.
+func UnsafeNewQAccessiblePlugin(h unsafe.Pointer) *QAccessiblePlugin {
+	return newQAccessiblePlugin((*C.QAccessiblePlugin)(h))
+}
+
+// NewQAccessiblePlugin constructs a new QAccessiblePlugin object.
+func NewQAccessiblePlugin() *QAccessiblePlugin {
+
+	return newQAccessiblePlugin(C.QAccessiblePlugin_new())
+}
+
+// NewQAccessiblePlugin2 constructs a new QAccessiblePlugin object.
+func NewQAccessiblePlugin2(parent *QObject) *QAccessiblePlugin {
+
+	return newQAccessiblePlugin(C.QAccessiblePlugin_new2(parent.cPointer()))
+}
+
+func (this *QAccessiblePlugin) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAccessiblePlugin_metaObject(this.h))
+}
+
+func (this *QAccessiblePlugin) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAccessiblePlugin_metacast(this.h, param1_Cstring))
+}
+
+func QAccessiblePlugin_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessiblePlugin_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAccessiblePlugin) Create(key string, object *QObject) *QAccessibleInterface {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	return newQAccessibleInterface(C.QAccessiblePlugin_create(this.h, key_ms, object.cPointer()))
+}
+
+func QAccessiblePlugin_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessiblePlugin_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAccessiblePlugin_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAccessiblePlugin_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QAccessiblePlugin that was directly constructed.
+func (this *QAccessiblePlugin) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QAccessiblePlugin_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QAccessiblePlugin that was directly constructed.
+func (this *QAccessiblePlugin) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAccessiblePlugin_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QAccessiblePlugin that was directly constructed.
+func (this *QAccessiblePlugin) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAccessiblePlugin_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QAccessiblePlugin that was directly constructed.
+func (this *QAccessiblePlugin) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QAccessiblePlugin_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+func (this *QAccessiblePlugin) OnCreate(slot func(key string, object *QObject) *QAccessibleInterface) {
+	ok := C.QAccessiblePlugin_override_virtual_create(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_create
+func miqt_exec_callback_QAccessiblePlugin_create(self *C.QAccessiblePlugin, cb C.intptr_t, key C.struct_miqt_string, object *C.QObject) *C.QAccessibleInterface {
+	gofunc, ok := cgo.Handle(cb).Value().(func(key string, object *QObject) *QAccessibleInterface)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var key_ms C.struct_miqt_string = key
+	key_ret := C.GoStringN(key_ms.data, C.int(int64(key_ms.len)))
+	C.free(unsafe.Pointer(key_ms.data))
+	slotval1 := key_ret
+	slotval2 := newQObject(object)
+
+	virtualReturn := gofunc(slotval1, slotval2)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAccessiblePlugin_virtualbase_event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAccessiblePlugin) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	ok := C.QAccessiblePlugin_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_event
+func miqt_exec_callback_QAccessiblePlugin_event(self *C.QAccessiblePlugin, 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 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAccessiblePlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAccessiblePlugin) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QAccessiblePlugin_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_eventFilter
+func miqt_exec_callback_QAccessiblePlugin_eventFilter(self *C.QAccessiblePlugin, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAccessiblePlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessiblePlugin) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QAccessiblePlugin_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_timerEvent
+func miqt_exec_callback_QAccessiblePlugin_timerEvent(self *C.QAccessiblePlugin, 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 := newQTimerEvent(event)
+
+	gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAccessiblePlugin_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessiblePlugin) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QAccessiblePlugin_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_childEvent
+func miqt_exec_callback_QAccessiblePlugin_childEvent(self *C.QAccessiblePlugin, 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 := newQChildEvent(event)
+
+	gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAccessiblePlugin_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAccessiblePlugin) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QAccessiblePlugin_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_customEvent
+func miqt_exec_callback_QAccessiblePlugin_customEvent(self *C.QAccessiblePlugin, 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 := newQEvent(event)
+
+	gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAccessiblePlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAccessiblePlugin) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAccessiblePlugin_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_connectNotify
+func miqt_exec_callback_QAccessiblePlugin_connectNotify(self *C.QAccessiblePlugin, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAccessiblePlugin) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAccessiblePlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAccessiblePlugin) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAccessiblePlugin_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAccessiblePlugin_disconnectNotify
+func miqt_exec_callback_QAccessiblePlugin_disconnectNotify(self *C.QAccessiblePlugin, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAccessiblePlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAccessiblePlugin) Delete() {
+	C.QAccessiblePlugin_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAccessiblePlugin) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAccessiblePlugin) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qaccessibleplugin.h

@@ -0,0 +1,75 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLEPLUGIN_H
+#define MIQT_QT6_GEN_QACCESSIBLEPLUGIN_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAccessibleInterface;
+class QAccessiblePlugin;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+#else
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QAccessiblePlugin QAccessiblePlugin;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QAccessiblePlugin* QAccessiblePlugin_new();
+QAccessiblePlugin* QAccessiblePlugin_new2(QObject* parent);
+void QAccessiblePlugin_virtbase(QAccessiblePlugin* src, QObject** outptr_QObject);
+QMetaObject* QAccessiblePlugin_metaObject(const QAccessiblePlugin* self);
+void* QAccessiblePlugin_metacast(QAccessiblePlugin* self, const char* param1);
+struct miqt_string QAccessiblePlugin_tr(const char* s);
+QAccessibleInterface* QAccessiblePlugin_create(QAccessiblePlugin* self, struct miqt_string key, QObject* object);
+struct miqt_string QAccessiblePlugin_tr2(const char* s, const char* c);
+struct miqt_string QAccessiblePlugin_tr3(const char* s, const char* c, int n);
+
+bool QAccessiblePlugin_override_virtual_create(void* self, intptr_t slot);
+QAccessibleInterface* QAccessiblePlugin_virtualbase_create(void* self, struct miqt_string key, QObject* object);
+bool QAccessiblePlugin_override_virtual_event(void* self, intptr_t slot);
+bool QAccessiblePlugin_virtualbase_event(void* self, QEvent* event);
+bool QAccessiblePlugin_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAccessiblePlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAccessiblePlugin_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAccessiblePlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAccessiblePlugin_override_virtual_childEvent(void* self, intptr_t slot);
+void QAccessiblePlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAccessiblePlugin_override_virtual_customEvent(void* self, intptr_t slot);
+void QAccessiblePlugin_virtualbase_customEvent(void* self, QEvent* event);
+bool QAccessiblePlugin_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAccessiblePlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAccessiblePlugin_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAccessiblePlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAccessiblePlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAccessiblePlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAccessiblePlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAccessiblePlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAccessiblePlugin_delete(QAccessiblePlugin* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblewidget.cpp

@@ -0,0 +1,178 @@
+#define WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State
+#include <QAccessibleActionInterface>
+#include <QAccessibleInterface>
+#include <QAccessibleObject>
+#include <QAccessibleWidget>
+#include <QColor>
+#include <QList>
+#include <QObject>
+#include <QPair>
+#include <QRect>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QWidget>
+#include <QWindow>
+#include <qaccessiblewidget.h>
+#include "gen_qaccessiblewidget.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QAccessibleWidget* QAccessibleWidget_new(QWidget* o) {
+	return new (std::nothrow) QAccessibleWidget(o);
+}
+
+QAccessibleWidget* QAccessibleWidget_new2(QWidget* o, int r) {
+	return new (std::nothrow) QAccessibleWidget(o, static_cast<QAccessible::Role>(r));
+}
+
+QAccessibleWidget* QAccessibleWidget_new3(QWidget* o, int r, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new (std::nothrow) QAccessibleWidget(o, static_cast<QAccessible::Role>(r), name_QString);
+}
+
+void QAccessibleWidget_virtbase(QAccessibleWidget* src, QAccessibleObject** outptr_QAccessibleObject, QAccessibleActionInterface** outptr_QAccessibleActionInterface) {
+	*outptr_QAccessibleObject = static_cast<QAccessibleObject*>(src);
+	*outptr_QAccessibleActionInterface = static_cast<QAccessibleActionInterface*>(src);
+}
+
+bool QAccessibleWidget_isValid(const QAccessibleWidget* self) {
+	return self->isValid();
+}
+
+QWindow* QAccessibleWidget_window(const QAccessibleWidget* self) {
+	return self->window();
+}
+
+int QAccessibleWidget_childCount(const QAccessibleWidget* self) {
+	return self->childCount();
+}
+
+int QAccessibleWidget_indexOfChild(const QAccessibleWidget* self, QAccessibleInterface* child) {
+	return self->indexOfChild(child);
+}
+
+struct miqt_array /* of struct miqt_map  tuple of QAccessibleInterface* and int   */  QAccessibleWidget_relations(const QAccessibleWidget* self, int match) {
+	QList<QPair<QAccessibleInterface *, QAccessible::Relation>> _ret = self->relations(static_cast<QAccessible::Relation>(match));
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast<struct miqt_map /* tuple of QAccessibleInterface* and int */ *>(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QPair<QAccessibleInterface*, QFlags<QAccessible::RelationFlag>> _lv_ret = _ret[i];
+		// Convert QPair<> from C++ memory to manually-managed C memory
+		QAccessibleInterface** _lv_first_arr = static_cast<QAccessibleInterface**>(malloc(sizeof(QAccessibleInterface*)));
+		int* _lv_second_arr = static_cast<int*>(malloc(sizeof(int)));
+		_lv_first_arr[0] = _lv_ret.first;
+		QFlags<QAccessible::RelationFlag> _lv_second_ret = _lv_ret.second;
+		_lv_second_arr[0] = static_cast<int>(_lv_second_ret);
+		struct miqt_map _lv_out;
+		_lv_out.len = 1;
+		_lv_out.keys = static_cast<void*>(_lv_first_arr);
+		_lv_out.values = static_cast<void*>(_lv_second_arr);
+		_arr[i] = _lv_out;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QAccessibleInterface* QAccessibleWidget_focusChild(const QAccessibleWidget* self) {
+	return self->focusChild();
+}
+
+QRect* QAccessibleWidget_rect(const QAccessibleWidget* self) {
+	return new QRect(self->rect());
+}
+
+QAccessibleInterface* QAccessibleWidget_parent(const QAccessibleWidget* self) {
+	return self->parent();
+}
+
+QAccessibleInterface* QAccessibleWidget_child(const QAccessibleWidget* self, int index) {
+	return self->child(static_cast<int>(index));
+}
+
+struct miqt_string QAccessibleWidget_text(const QAccessibleWidget* self, int t) {
+	QString _ret = self->text(static_cast<QAccessible::Text>(t));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QAccessibleWidget_role(const QAccessibleWidget* self) {
+	QAccessible::Role _ret = self->role();
+	return static_cast<int>(_ret);
+}
+
+QAccessible__State* QAccessibleWidget_state(const QAccessibleWidget* self) {
+	return new QAccessible::State(self->state());
+}
+
+QColor* QAccessibleWidget_foregroundColor(const QAccessibleWidget* self) {
+	return new QColor(self->foregroundColor());
+}
+
+QColor* QAccessibleWidget_backgroundColor(const QAccessibleWidget* self) {
+	return new QColor(self->backgroundColor());
+}
+
+void* QAccessibleWidget_interfaceCast(QAccessibleWidget* self, int t) {
+	return self->interface_cast(static_cast<QAccessible::InterfaceType>(t));
+}
+
+struct miqt_array /* of struct miqt_string */  QAccessibleWidget_actionNames(const QAccessibleWidget* self) {
+	QStringList _ret = self->actionNames();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QAccessibleWidget_doAction(QAccessibleWidget* self, struct miqt_string actionName) {
+	QString actionName_QString = QString::fromUtf8(actionName.data, actionName.len);
+	self->doAction(actionName_QString);
+}
+
+struct miqt_array /* of struct miqt_string */  QAccessibleWidget_keyBindingsForAction(const QAccessibleWidget* self, struct miqt_string actionName) {
+	QString actionName_QString = QString::fromUtf8(actionName.data, actionName.len);
+	QStringList _ret = self->keyBindingsForAction(actionName_QString);
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblewidget.go

@@ -0,0 +1,205 @@
+package qt6
+
+/*
+
+#include "gen_qaccessiblewidget.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"unsafe"
+)
+
+type QAccessibleWidget struct {
+	h *C.QAccessibleWidget
+	*QAccessibleObject
+	*QAccessibleActionInterface
+}
+
+func (this *QAccessibleWidget) cPointer() *C.QAccessibleWidget {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAccessibleWidget) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAccessibleWidget constructs the type using only CGO pointers.
+func newQAccessibleWidget(h *C.QAccessibleWidget) *QAccessibleWidget {
+	if h == nil {
+		return nil
+	}
+	var outptr_QAccessibleObject *C.QAccessibleObject = nil
+	var outptr_QAccessibleActionInterface *C.QAccessibleActionInterface = nil
+	C.QAccessibleWidget_virtbase(h, &outptr_QAccessibleObject, &outptr_QAccessibleActionInterface)
+
+	return &QAccessibleWidget{h: h,
+		QAccessibleObject:          newQAccessibleObject(outptr_QAccessibleObject),
+		QAccessibleActionInterface: newQAccessibleActionInterface(outptr_QAccessibleActionInterface)}
+}
+
+// UnsafeNewQAccessibleWidget constructs the type using only unsafe pointers.
+func UnsafeNewQAccessibleWidget(h unsafe.Pointer) *QAccessibleWidget {
+	return newQAccessibleWidget((*C.QAccessibleWidget)(h))
+}
+
+// NewQAccessibleWidget constructs a new QAccessibleWidget object.
+func NewQAccessibleWidget(o *QWidget) *QAccessibleWidget {
+
+	return newQAccessibleWidget(C.QAccessibleWidget_new(o.cPointer()))
+}
+
+// NewQAccessibleWidget2 constructs a new QAccessibleWidget object.
+func NewQAccessibleWidget2(o *QWidget, r QAccessible__Role) *QAccessibleWidget {
+
+	return newQAccessibleWidget(C.QAccessibleWidget_new2(o.cPointer(), (C.int)(r)))
+}
+
+// NewQAccessibleWidget3 constructs a new QAccessibleWidget object.
+func NewQAccessibleWidget3(o *QWidget, r QAccessible__Role, name string) *QAccessibleWidget {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+
+	return newQAccessibleWidget(C.QAccessibleWidget_new3(o.cPointer(), (C.int)(r), name_ms))
+}
+
+func (this *QAccessibleWidget) IsValid() bool {
+	return (bool)(C.QAccessibleWidget_isValid(this.h))
+}
+
+func (this *QAccessibleWidget) Window() *QWindow {
+	return newQWindow(C.QAccessibleWidget_window(this.h))
+}
+
+func (this *QAccessibleWidget) ChildCount() int {
+	return (int)(C.QAccessibleWidget_childCount(this.h))
+}
+
+func (this *QAccessibleWidget) IndexOfChild(child *QAccessibleInterface) int {
+	return (int)(C.QAccessibleWidget_indexOfChild(this.h, child.cPointer()))
+}
+
+func (this *QAccessibleWidget) Relations(match QAccessible__RelationFlag) []struct {
+	First  *QAccessibleInterface
+	Second QAccessible__RelationFlag
+} {
+	var _ma C.struct_miqt_array = C.QAccessibleWidget_relations(this.h, (C.int)(match))
+	_ret := make([]struct {
+		First  *QAccessibleInterface
+		Second QAccessible__RelationFlag
+	}, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_map)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_mm C.struct_miqt_map = _outCast[i]
+		_lv_First_CArray := (*[0xffff]*C.QAccessibleInterface)(unsafe.Pointer(_lv_mm.keys))
+		_lv_Second_CArray := (*[0xffff]C.int)(unsafe.Pointer(_lv_mm.values))
+		_lv_entry_First := newQAccessibleInterface(_lv_First_CArray[0])
+
+		_lv_entry_Second := (QAccessible__RelationFlag)(_lv_Second_CArray[0])
+
+		_ret[i] = struct {
+			First  *QAccessibleInterface
+			Second QAccessible__RelationFlag
+		}{First: _lv_entry_First, Second: _lv_entry_Second}
+	}
+	return _ret
+}
+
+func (this *QAccessibleWidget) FocusChild() *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleWidget_focusChild(this.h))
+}
+
+func (this *QAccessibleWidget) Rect() *QRect {
+	_goptr := newQRect(C.QAccessibleWidget_rect(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAccessibleWidget) Parent() *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleWidget_parent(this.h))
+}
+
+func (this *QAccessibleWidget) Child(index int) *QAccessibleInterface {
+	return newQAccessibleInterface(C.QAccessibleWidget_child(this.h, (C.int)(index)))
+}
+
+func (this *QAccessibleWidget) Text(t QAccessible__Text) string {
+	var _ms C.struct_miqt_string = C.QAccessibleWidget_text(this.h, (C.int)(t))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAccessibleWidget) Role() QAccessible__Role {
+	return (QAccessible__Role)(C.QAccessibleWidget_role(this.h))
+}
+
+func (this *QAccessibleWidget) State() *QAccessible__State {
+	_goptr := newQAccessible__State(C.QAccessibleWidget_state(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAccessibleWidget) ForegroundColor() *QColor {
+	_goptr := newQColor(C.QAccessibleWidget_foregroundColor(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAccessibleWidget) BackgroundColor() *QColor {
+	_goptr := newQColor(C.QAccessibleWidget_backgroundColor(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAccessibleWidget) InterfaceCast(t QAccessible__InterfaceType) unsafe.Pointer {
+	return (unsafe.Pointer)(C.QAccessibleWidget_interfaceCast(this.h, (C.int)(t)))
+}
+
+func (this *QAccessibleWidget) ActionNames() []string {
+	var _ma C.struct_miqt_array = C.QAccessibleWidget_actionNames(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 *QAccessibleWidget) DoAction(actionName string) {
+	actionName_ms := C.struct_miqt_string{}
+	actionName_ms.data = C.CString(actionName)
+	actionName_ms.len = C.size_t(len(actionName))
+	defer C.free(unsafe.Pointer(actionName_ms.data))
+	C.QAccessibleWidget_doAction(this.h, actionName_ms)
+}
+
+func (this *QAccessibleWidget) KeyBindingsForAction(actionName string) []string {
+	actionName_ms := C.struct_miqt_string{}
+	actionName_ms.data = C.CString(actionName)
+	actionName_ms.len = C.size_t(len(actionName))
+	defer C.free(unsafe.Pointer(actionName_ms.data))
+	var _ma C.struct_miqt_array = C.QAccessibleWidget_keyBindingsForAction(this.h, actionName_ms)
+	_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
+}

vendor/github.com/mappu/miqt/qt6/gen_qaccessiblewidget.h

@@ -0,0 +1,73 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACCESSIBLEWIDGET_H
+#define MIQT_QT6_GEN_QACCESSIBLEWIDGET_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QAccessible__State)
+typedef QAccessible::State QAccessible__State;
+#else
+class QAccessible__State;
+#endif
+class QAccessibleActionInterface;
+class QAccessibleInterface;
+class QAccessibleObject;
+class QAccessibleWidget;
+class QColor;
+class QObject;
+class QRect;
+class QWidget;
+class QWindow;
+#else
+typedef struct QAccessible__State QAccessible__State;
+typedef struct QAccessibleActionInterface QAccessibleActionInterface;
+typedef struct QAccessibleInterface QAccessibleInterface;
+typedef struct QAccessibleObject QAccessibleObject;
+typedef struct QAccessibleWidget QAccessibleWidget;
+typedef struct QColor QColor;
+typedef struct QObject QObject;
+typedef struct QRect QRect;
+typedef struct QWidget QWidget;
+typedef struct QWindow QWindow;
+#endif
+
+QAccessibleWidget* QAccessibleWidget_new(QWidget* o);
+QAccessibleWidget* QAccessibleWidget_new2(QWidget* o, int r);
+QAccessibleWidget* QAccessibleWidget_new3(QWidget* o, int r, struct miqt_string name);
+void QAccessibleWidget_virtbase(QAccessibleWidget* src, QAccessibleObject** outptr_QAccessibleObject, QAccessibleActionInterface** outptr_QAccessibleActionInterface);
+bool QAccessibleWidget_isValid(const QAccessibleWidget* self);
+QWindow* QAccessibleWidget_window(const QAccessibleWidget* self);
+int QAccessibleWidget_childCount(const QAccessibleWidget* self);
+int QAccessibleWidget_indexOfChild(const QAccessibleWidget* self, QAccessibleInterface* child);
+struct miqt_array /* of struct miqt_map  tuple of QAccessibleInterface* and int   */  QAccessibleWidget_relations(const QAccessibleWidget* self, int match);
+QAccessibleInterface* QAccessibleWidget_focusChild(const QAccessibleWidget* self);
+QRect* QAccessibleWidget_rect(const QAccessibleWidget* self);
+QAccessibleInterface* QAccessibleWidget_parent(const QAccessibleWidget* self);
+QAccessibleInterface* QAccessibleWidget_child(const QAccessibleWidget* self, int index);
+struct miqt_string QAccessibleWidget_text(const QAccessibleWidget* self, int t);
+int QAccessibleWidget_role(const QAccessibleWidget* self);
+QAccessible__State* QAccessibleWidget_state(const QAccessibleWidget* self);
+QColor* QAccessibleWidget_foregroundColor(const QAccessibleWidget* self);
+QColor* QAccessibleWidget_backgroundColor(const QAccessibleWidget* self);
+void* QAccessibleWidget_interfaceCast(QAccessibleWidget* self, int t);
+struct miqt_array /* of struct miqt_string */  QAccessibleWidget_actionNames(const QAccessibleWidget* self);
+void QAccessibleWidget_doAction(QAccessibleWidget* self, struct miqt_string actionName);
+struct miqt_array /* of struct miqt_string */  QAccessibleWidget_keyBindingsForAction(const QAccessibleWidget* self, struct miqt_string actionName);
+
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qaction.cpp

@@ -0,0 +1,769 @@
+#include <QAction>
+#include <QActionGroup>
+#include <QChildEvent>
+#include <QEvent>
+#include <QFont>
+#include <QIcon>
+#include <QKeySequence>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <QVariant>
+#include <qaction.h>
+#include "gen_qaction.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QAction_changed(intptr_t);
+void miqt_exec_callback_QAction_enabledChanged(intptr_t, bool);
+void miqt_exec_callback_QAction_checkableChanged(intptr_t, bool);
+void miqt_exec_callback_QAction_visibleChanged(intptr_t);
+void miqt_exec_callback_QAction_triggered(intptr_t);
+void miqt_exec_callback_QAction_hovered(intptr_t);
+void miqt_exec_callback_QAction_toggled(intptr_t, bool);
+void miqt_exec_callback_QAction_triggeredWithChecked(intptr_t, bool);
+bool miqt_exec_callback_QAction_event(QAction*, intptr_t, QEvent*);
+bool miqt_exec_callback_QAction_eventFilter(QAction*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAction_timerEvent(QAction*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAction_childEvent(QAction*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAction_customEvent(QAction*, intptr_t, QEvent*);
+void miqt_exec_callback_QAction_connectNotify(QAction*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAction_disconnectNotify(QAction*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAction final : public QAction {
+public:
+
+	MiqtVirtualQAction(): QAction() {}
+	MiqtVirtualQAction(const QString& text): QAction(text) {}
+	MiqtVirtualQAction(const QIcon& icon, const QString& text): QAction(icon, text) {}
+	MiqtVirtualQAction(QObject* parent): QAction(parent) {}
+	MiqtVirtualQAction(const QString& text, QObject* parent): QAction(text, parent) {}
+	MiqtVirtualQAction(const QIcon& icon, const QString& text, QObject* parent): QAction(icon, text, parent) {}
+
+	virtual ~MiqtVirtualQAction() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* param1) override {
+		if (handle__event == 0) {
+			return QAction::event(param1);
+		}
+
+		QEvent* sigval1 = param1;
+		bool callback_return_value = miqt_exec_callback_QAction_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAction_virtualbase_event(void* self, QEvent* param1);
+
+	// 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 QAction::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAction_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAction_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QAction::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAction_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAction_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QAction::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAction_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAction_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QAction::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAction_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAction_virtualbase_customEvent(void* self, QEvent* 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) {
+			QAction::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAction_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAction_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QAction::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAction_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAction_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QAction_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAction_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAction_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAction_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAction* QAction_new() {
+	return new (std::nothrow) MiqtVirtualQAction();
+}
+
+QAction* QAction_new2(struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return new (std::nothrow) MiqtVirtualQAction(text_QString);
+}
+
+QAction* QAction_new3(QIcon* icon, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return new (std::nothrow) MiqtVirtualQAction(*icon, text_QString);
+}
+
+QAction* QAction_new4(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQAction(parent);
+}
+
+QAction* QAction_new5(struct miqt_string text, QObject* parent) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return new (std::nothrow) MiqtVirtualQAction(text_QString, parent);
+}
+
+QAction* QAction_new6(QIcon* icon, struct miqt_string text, QObject* parent) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return new (std::nothrow) MiqtVirtualQAction(*icon, text_QString, parent);
+}
+
+void QAction_virtbase(QAction* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QAction_metaObject(const QAction* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAction_metacast(QAction* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAction_tr(const char* s) {
+	QString _ret = QAction::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_array /* of QObject* */  QAction_associatedObjects(const QAction* self) {
+	QList<QObject *> _ret = self->associatedObjects();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QObject** _arr = static_cast<QObject**>(malloc(sizeof(QObject*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QAction_setActionGroup(QAction* self, QActionGroup* group) {
+	self->setActionGroup(group);
+}
+
+QActionGroup* QAction_actionGroup(const QAction* self) {
+	return self->actionGroup();
+}
+
+void QAction_setIcon(QAction* self, QIcon* icon) {
+	self->setIcon(*icon);
+}
+
+QIcon* QAction_icon(const QAction* self) {
+	return new QIcon(self->icon());
+}
+
+void QAction_setText(QAction* self, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	self->setText(text_QString);
+}
+
+struct miqt_string QAction_text(const QAction* self) {
+	QString _ret = self->text();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAction_setIconText(QAction* self, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	self->setIconText(text_QString);
+}
+
+struct miqt_string QAction_iconText(const QAction* self) {
+	QString _ret = self->iconText();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAction_setToolTip(QAction* self, struct miqt_string tip) {
+	QString tip_QString = QString::fromUtf8(tip.data, tip.len);
+	self->setToolTip(tip_QString);
+}
+
+struct miqt_string QAction_toolTip(const QAction* self) {
+	QString _ret = self->toolTip();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAction_setStatusTip(QAction* self, struct miqt_string statusTip) {
+	QString statusTip_QString = QString::fromUtf8(statusTip.data, statusTip.len);
+	self->setStatusTip(statusTip_QString);
+}
+
+struct miqt_string QAction_statusTip(const QAction* self) {
+	QString _ret = self->statusTip();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAction_setWhatsThis(QAction* self, struct miqt_string what) {
+	QString what_QString = QString::fromUtf8(what.data, what.len);
+	self->setWhatsThis(what_QString);
+}
+
+struct miqt_string QAction_whatsThis(const QAction* self) {
+	QString _ret = self->whatsThis();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QAction_setPriority(QAction* self, int priority) {
+	self->setPriority(static_cast<QAction::Priority>(priority));
+}
+
+int QAction_priority(const QAction* self) {
+	QAction::Priority _ret = self->priority();
+	return static_cast<int>(_ret);
+}
+
+void QAction_setSeparator(QAction* self, bool b) {
+	self->setSeparator(b);
+}
+
+bool QAction_isSeparator(const QAction* self) {
+	return self->isSeparator();
+}
+
+void QAction_setShortcut(QAction* self, QKeySequence* shortcut) {
+	self->setShortcut(*shortcut);
+}
+
+QKeySequence* QAction_shortcut(const QAction* self) {
+	return new QKeySequence(self->shortcut());
+}
+
+void QAction_setShortcuts(QAction* self, struct miqt_array /* of QKeySequence* */  shortcuts) {
+	QList<QKeySequence> shortcuts_QList;
+	shortcuts_QList.reserve(shortcuts.len);
+	QKeySequence** shortcuts_arr = static_cast<QKeySequence**>(shortcuts.data);
+	for(size_t i = 0; i < shortcuts.len; ++i) {
+		shortcuts_QList.push_back(*(shortcuts_arr[i]));
+	}
+	self->setShortcuts(shortcuts_QList);
+}
+
+void QAction_setShortcutsWithShortcuts(QAction* self, int shortcuts) {
+	self->setShortcuts(static_cast<QKeySequence::StandardKey>(shortcuts));
+}
+
+struct miqt_array /* of QKeySequence* */  QAction_shortcuts(const QAction* self) {
+	QList<QKeySequence> _ret = self->shortcuts();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QKeySequence** _arr = static_cast<QKeySequence**>(malloc(sizeof(QKeySequence*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = new QKeySequence(_ret[i]);
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QAction_setShortcutContext(QAction* self, int context) {
+	self->setShortcutContext(static_cast<Qt::ShortcutContext>(context));
+}
+
+int QAction_shortcutContext(const QAction* self) {
+	Qt::ShortcutContext _ret = self->shortcutContext();
+	return static_cast<int>(_ret);
+}
+
+void QAction_setAutoRepeat(QAction* self, bool autoRepeat) {
+	self->setAutoRepeat(autoRepeat);
+}
+
+bool QAction_autoRepeat(const QAction* self) {
+	return self->autoRepeat();
+}
+
+void QAction_setFont(QAction* self, QFont* font) {
+	self->setFont(*font);
+}
+
+QFont* QAction_font(const QAction* self) {
+	return new QFont(self->font());
+}
+
+void QAction_setCheckable(QAction* self, bool checkable) {
+	self->setCheckable(checkable);
+}
+
+bool QAction_isCheckable(const QAction* self) {
+	return self->isCheckable();
+}
+
+QVariant* QAction_data(const QAction* self) {
+	return new QVariant(self->data());
+}
+
+void QAction_setData(QAction* self, QVariant* var) {
+	self->setData(*var);
+}
+
+bool QAction_isChecked(const QAction* self) {
+	return self->isChecked();
+}
+
+bool QAction_isEnabled(const QAction* self) {
+	return self->isEnabled();
+}
+
+bool QAction_isVisible(const QAction* self) {
+	return self->isVisible();
+}
+
+void QAction_activate(QAction* self, int event) {
+	self->activate(static_cast<QAction::ActionEvent>(event));
+}
+
+void QAction_setMenuRole(QAction* self, int menuRole) {
+	self->setMenuRole(static_cast<QAction::MenuRole>(menuRole));
+}
+
+int QAction_menuRole(const QAction* self) {
+	QAction::MenuRole _ret = self->menuRole();
+	return static_cast<int>(_ret);
+}
+
+void QAction_setIconVisibleInMenu(QAction* self, bool visible) {
+	self->setIconVisibleInMenu(visible);
+}
+
+bool QAction_isIconVisibleInMenu(const QAction* self) {
+	return self->isIconVisibleInMenu();
+}
+
+void QAction_setShortcutVisibleInContextMenu(QAction* self, bool show) {
+	self->setShortcutVisibleInContextMenu(show);
+}
+
+bool QAction_isShortcutVisibleInContextMenu(const QAction* self) {
+	return self->isShortcutVisibleInContextMenu();
+}
+
+bool QAction_showStatusText(QAction* self) {
+	return self->showStatusText();
+}
+
+void QAction_trigger(QAction* self) {
+	self->trigger();
+}
+
+void QAction_hover(QAction* self) {
+	self->hover();
+}
+
+void QAction_setChecked(QAction* self, bool checked) {
+	self->setChecked(checked);
+}
+
+void QAction_toggle(QAction* self) {
+	self->toggle();
+}
+
+void QAction_setEnabled(QAction* self, bool enabled) {
+	self->setEnabled(enabled);
+}
+
+void QAction_resetEnabled(QAction* self) {
+	self->resetEnabled();
+}
+
+void QAction_setDisabled(QAction* self, bool b) {
+	self->setDisabled(b);
+}
+
+void QAction_setVisible(QAction* self, bool visible) {
+	self->setVisible(visible);
+}
+
+void QAction_changed(QAction* self) {
+	self->changed();
+}
+
+void QAction_connect_changed(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)()>(&QAction::changed), self, [=]() {
+		miqt_exec_callback_QAction_changed(slot);
+	});
+}
+
+void QAction_enabledChanged(QAction* self, bool enabled) {
+	self->enabledChanged(enabled);
+}
+
+void QAction_connect_enabledChanged(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::enabledChanged), self, [=](bool enabled) {
+		bool sigval1 = enabled;
+		miqt_exec_callback_QAction_enabledChanged(slot, sigval1);
+	});
+}
+
+void QAction_checkableChanged(QAction* self, bool checkable) {
+	self->checkableChanged(checkable);
+}
+
+void QAction_connect_checkableChanged(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::checkableChanged), self, [=](bool checkable) {
+		bool sigval1 = checkable;
+		miqt_exec_callback_QAction_checkableChanged(slot, sigval1);
+	});
+}
+
+void QAction_visibleChanged(QAction* self) {
+	self->visibleChanged();
+}
+
+void QAction_connect_visibleChanged(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)()>(&QAction::visibleChanged), self, [=]() {
+		miqt_exec_callback_QAction_visibleChanged(slot);
+	});
+}
+
+void QAction_triggered(QAction* self) {
+	self->triggered();
+}
+
+void QAction_connect_triggered(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::triggered), self, [=]() {
+		miqt_exec_callback_QAction_triggered(slot);
+	});
+}
+
+void QAction_hovered(QAction* self) {
+	self->hovered();
+}
+
+void QAction_connect_hovered(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)()>(&QAction::hovered), self, [=]() {
+		miqt_exec_callback_QAction_hovered(slot);
+	});
+}
+
+void QAction_toggled(QAction* self, bool param1) {
+	self->toggled(param1);
+}
+
+void QAction_connect_toggled(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::toggled), self, [=](bool param1) {
+		bool sigval1 = param1;
+		miqt_exec_callback_QAction_toggled(slot, sigval1);
+	});
+}
+
+struct miqt_string QAction_tr2(const char* s, const char* c) {
+	QString _ret = QAction::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAction_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAction::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QAction_showStatusTextWithObject(QAction* self, QObject* object) {
+	return self->showStatusText(object);
+}
+
+void QAction_triggeredWithChecked(QAction* self, bool checked) {
+	self->triggered(checked);
+}
+
+void QAction_connect_triggeredWithChecked(QAction* self, intptr_t slot) {
+	QAction::connect(self, static_cast<void (QAction::*)(bool)>(&QAction::triggered), self, [=](bool checked) {
+		bool sigval1 = checked;
+		miqt_exec_callback_QAction_triggeredWithChecked(slot, sigval1);
+	});
+}
+
+bool QAction_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAction_virtualbase_event(void* self, QEvent* param1) {
+	return static_cast<MiqtVirtualQAction*>(self)->QAction::event(param1);
+}
+
+bool QAction_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAction_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAction*>(self)->QAction::eventFilter(watched, event);
+}
+
+bool QAction_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAction_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAction*>(self)->QAction::timerEvent(event);
+}
+
+bool QAction_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAction_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAction*>(self)->QAction::childEvent(event);
+}
+
+bool QAction_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAction_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAction*>(self)->QAction::customEvent(event);
+}
+
+bool QAction_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAction_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAction*>(self)->QAction::connectNotify(*signal);
+}
+
+bool QAction_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAction_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAction*>(self)->QAction::disconnectNotify(*signal);
+}
+
+QObject* QAction_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAction_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAction_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAction_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAction* self_cast = dynamic_cast<MiqtVirtualQAction*>( (QAction*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAction_delete(QAction* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qaction.go

@@ -0,0 +1,858 @@
+package qt6
+
+/*
+
+#include "gen_qaction.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAction__MenuRole int
+
+const (
+	QAction__NoRole                  QAction__MenuRole = 0
+	QAction__TextHeuristicRole       QAction__MenuRole = 1
+	QAction__ApplicationSpecificRole QAction__MenuRole = 2
+	QAction__AboutQtRole             QAction__MenuRole = 3
+	QAction__AboutRole               QAction__MenuRole = 4
+	QAction__PreferencesRole         QAction__MenuRole = 5
+	QAction__QuitRole                QAction__MenuRole = 6
+)
+
+type QAction__Priority int
+
+const (
+	QAction__LowPriority    QAction__Priority = 0
+	QAction__NormalPriority QAction__Priority = 128
+	QAction__HighPriority   QAction__Priority = 256
+)
+
+type QAction__ActionEvent int
+
+const (
+	QAction__Trigger QAction__ActionEvent = 0
+	QAction__Hover   QAction__ActionEvent = 1
+)
+
+type QAction struct {
+	h *C.QAction
+	*QObject
+}
+
+func (this *QAction) cPointer() *C.QAction {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAction) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAction constructs the type using only CGO pointers.
+func newQAction(h *C.QAction) *QAction {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QAction_virtbase(h, &outptr_QObject)
+
+	return &QAction{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQAction constructs the type using only unsafe pointers.
+func UnsafeNewQAction(h unsafe.Pointer) *QAction {
+	return newQAction((*C.QAction)(h))
+}
+
+// NewQAction constructs a new QAction object.
+func NewQAction() *QAction {
+
+	return newQAction(C.QAction_new())
+}
+
+// NewQAction2 constructs a new QAction object.
+func NewQAction2(text string) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+
+	return newQAction(C.QAction_new2(text_ms))
+}
+
+// NewQAction3 constructs a new QAction object.
+func NewQAction3(icon *QIcon, text string) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+
+	return newQAction(C.QAction_new3(icon.cPointer(), text_ms))
+}
+
+// NewQAction4 constructs a new QAction object.
+func NewQAction4(parent *QObject) *QAction {
+
+	return newQAction(C.QAction_new4(parent.cPointer()))
+}
+
+// NewQAction5 constructs a new QAction object.
+func NewQAction5(text string, parent *QObject) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+
+	return newQAction(C.QAction_new5(text_ms, parent.cPointer()))
+}
+
+// NewQAction6 constructs a new QAction object.
+func NewQAction6(icon *QIcon, text string, parent *QObject) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+
+	return newQAction(C.QAction_new6(icon.cPointer(), text_ms, parent.cPointer()))
+}
+
+func (this *QAction) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAction_metaObject(this.h))
+}
+
+func (this *QAction) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAction_metacast(this.h, param1_Cstring))
+}
+
+func QAction_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAction_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) AssociatedObjects() []*QObject {
+	var _ma C.struct_miqt_array = C.QAction_associatedObjects(this.h)
+	_ret := make([]*QObject, int(_ma.len))
+	_outCast := (*[0xffff]*C.QObject)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = newQObject(_outCast[i])
+	}
+	return _ret
+}
+
+func (this *QAction) SetActionGroup(group *QActionGroup) {
+	C.QAction_setActionGroup(this.h, group.cPointer())
+}
+
+func (this *QAction) ActionGroup() *QActionGroup {
+	return newQActionGroup(C.QAction_actionGroup(this.h))
+}
+
+func (this *QAction) SetIcon(icon *QIcon) {
+	C.QAction_setIcon(this.h, icon.cPointer())
+}
+
+func (this *QAction) Icon() *QIcon {
+	_goptr := newQIcon(C.QAction_icon(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAction) SetText(text string) {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+	C.QAction_setText(this.h, text_ms)
+}
+
+func (this *QAction) Text() string {
+	var _ms C.struct_miqt_string = C.QAction_text(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) SetIconText(text string) {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+	C.QAction_setIconText(this.h, text_ms)
+}
+
+func (this *QAction) IconText() string {
+	var _ms C.struct_miqt_string = C.QAction_iconText(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) SetToolTip(tip string) {
+	tip_ms := C.struct_miqt_string{}
+	tip_ms.data = C.CString(tip)
+	tip_ms.len = C.size_t(len(tip))
+	defer C.free(unsafe.Pointer(tip_ms.data))
+	C.QAction_setToolTip(this.h, tip_ms)
+}
+
+func (this *QAction) ToolTip() string {
+	var _ms C.struct_miqt_string = C.QAction_toolTip(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) SetStatusTip(statusTip string) {
+	statusTip_ms := C.struct_miqt_string{}
+	statusTip_ms.data = C.CString(statusTip)
+	statusTip_ms.len = C.size_t(len(statusTip))
+	defer C.free(unsafe.Pointer(statusTip_ms.data))
+	C.QAction_setStatusTip(this.h, statusTip_ms)
+}
+
+func (this *QAction) StatusTip() string {
+	var _ms C.struct_miqt_string = C.QAction_statusTip(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) SetWhatsThis(what string) {
+	what_ms := C.struct_miqt_string{}
+	what_ms.data = C.CString(what)
+	what_ms.len = C.size_t(len(what))
+	defer C.free(unsafe.Pointer(what_ms.data))
+	C.QAction_setWhatsThis(this.h, what_ms)
+}
+
+func (this *QAction) WhatsThis() string {
+	var _ms C.struct_miqt_string = C.QAction_whatsThis(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) SetPriority(priority QAction__Priority) {
+	C.QAction_setPriority(this.h, (C.int)(priority))
+}
+
+func (this *QAction) Priority() QAction__Priority {
+	return (QAction__Priority)(C.QAction_priority(this.h))
+}
+
+func (this *QAction) SetSeparator(b bool) {
+	C.QAction_setSeparator(this.h, (C.bool)(b))
+}
+
+func (this *QAction) IsSeparator() bool {
+	return (bool)(C.QAction_isSeparator(this.h))
+}
+
+func (this *QAction) SetShortcut(shortcut *QKeySequence) {
+	C.QAction_setShortcut(this.h, shortcut.cPointer())
+}
+
+func (this *QAction) Shortcut() *QKeySequence {
+	_goptr := newQKeySequence(C.QAction_shortcut(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAction) SetShortcuts(shortcuts []QKeySequence) {
+	shortcuts_CArray := (*[0xffff]*C.QKeySequence)(C.malloc(C.size_t(8 * len(shortcuts))))
+	defer C.free(unsafe.Pointer(shortcuts_CArray))
+	for i := range shortcuts {
+		shortcuts_CArray[i] = shortcuts[i].cPointer()
+	}
+	shortcuts_ma := C.struct_miqt_array{len: C.size_t(len(shortcuts)), data: unsafe.Pointer(shortcuts_CArray)}
+	C.QAction_setShortcuts(this.h, shortcuts_ma)
+}
+
+func (this *QAction) SetShortcutsWithShortcuts(shortcuts QKeySequence__StandardKey) {
+	C.QAction_setShortcutsWithShortcuts(this.h, (C.int)(shortcuts))
+}
+
+func (this *QAction) Shortcuts() []QKeySequence {
+	var _ma C.struct_miqt_array = C.QAction_shortcuts(this.h)
+	_ret := make([]QKeySequence, int(_ma.len))
+	_outCast := (*[0xffff]*C.QKeySequence)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_lv_goptr := newQKeySequence(_outCast[i])
+		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+		_ret[i] = *_lv_goptr
+	}
+	return _ret
+}
+
+func (this *QAction) SetShortcutContext(context ShortcutContext) {
+	C.QAction_setShortcutContext(this.h, (C.int)(context))
+}
+
+func (this *QAction) ShortcutContext() ShortcutContext {
+	return (ShortcutContext)(C.QAction_shortcutContext(this.h))
+}
+
+func (this *QAction) SetAutoRepeat(autoRepeat bool) {
+	C.QAction_setAutoRepeat(this.h, (C.bool)(autoRepeat))
+}
+
+func (this *QAction) AutoRepeat() bool {
+	return (bool)(C.QAction_autoRepeat(this.h))
+}
+
+func (this *QAction) SetFont(font *QFont) {
+	C.QAction_setFont(this.h, font.cPointer())
+}
+
+func (this *QAction) Font() *QFont {
+	_goptr := newQFont(C.QAction_font(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAction) SetCheckable(checkable bool) {
+	C.QAction_setCheckable(this.h, (C.bool)(checkable))
+}
+
+func (this *QAction) IsCheckable() bool {
+	return (bool)(C.QAction_isCheckable(this.h))
+}
+
+func (this *QAction) Data() *QVariant {
+	_goptr := newQVariant(C.QAction_data(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAction) SetData(varVal *QVariant) {
+	C.QAction_setData(this.h, varVal.cPointer())
+}
+
+func (this *QAction) IsChecked() bool {
+	return (bool)(C.QAction_isChecked(this.h))
+}
+
+func (this *QAction) IsEnabled() bool {
+	return (bool)(C.QAction_isEnabled(this.h))
+}
+
+func (this *QAction) IsVisible() bool {
+	return (bool)(C.QAction_isVisible(this.h))
+}
+
+func (this *QAction) Activate(event QAction__ActionEvent) {
+	C.QAction_activate(this.h, (C.int)(event))
+}
+
+func (this *QAction) SetMenuRole(menuRole QAction__MenuRole) {
+	C.QAction_setMenuRole(this.h, (C.int)(menuRole))
+}
+
+func (this *QAction) MenuRole() QAction__MenuRole {
+	return (QAction__MenuRole)(C.QAction_menuRole(this.h))
+}
+
+func (this *QAction) SetIconVisibleInMenu(visible bool) {
+	C.QAction_setIconVisibleInMenu(this.h, (C.bool)(visible))
+}
+
+func (this *QAction) IsIconVisibleInMenu() bool {
+	return (bool)(C.QAction_isIconVisibleInMenu(this.h))
+}
+
+func (this *QAction) SetShortcutVisibleInContextMenu(show bool) {
+	C.QAction_setShortcutVisibleInContextMenu(this.h, (C.bool)(show))
+}
+
+func (this *QAction) IsShortcutVisibleInContextMenu() bool {
+	return (bool)(C.QAction_isShortcutVisibleInContextMenu(this.h))
+}
+
+func (this *QAction) ShowStatusText() bool {
+	return (bool)(C.QAction_showStatusText(this.h))
+}
+
+func (this *QAction) Trigger() {
+	C.QAction_trigger(this.h)
+}
+
+func (this *QAction) Hover() {
+	C.QAction_hover(this.h)
+}
+
+func (this *QAction) SetChecked(checked bool) {
+	C.QAction_setChecked(this.h, (C.bool)(checked))
+}
+
+func (this *QAction) Toggle() {
+	C.QAction_toggle(this.h)
+}
+
+func (this *QAction) SetEnabled(enabled bool) {
+	C.QAction_setEnabled(this.h, (C.bool)(enabled))
+}
+
+func (this *QAction) ResetEnabled() {
+	C.QAction_resetEnabled(this.h)
+}
+
+func (this *QAction) SetDisabled(b bool) {
+	C.QAction_setDisabled(this.h, (C.bool)(b))
+}
+
+func (this *QAction) SetVisible(visible bool) {
+	C.QAction_setVisible(this.h, (C.bool)(visible))
+}
+
+func (this *QAction) Changed() {
+	C.QAction_changed(this.h)
+}
+func (this *QAction) OnChanged(slot func()) {
+	C.QAction_connect_changed(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_changed
+func miqt_exec_callback_QAction_changed(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func (this *QAction) EnabledChanged(enabled bool) {
+	C.QAction_enabledChanged(this.h, (C.bool)(enabled))
+}
+func (this *QAction) OnEnabledChanged(slot func(enabled bool)) {
+	C.QAction_connect_enabledChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_enabledChanged
+func miqt_exec_callback_QAction_enabledChanged(cb C.intptr_t, enabled C.bool) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(enabled bool))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(enabled)
+
+	gofunc(slotval1)
+}
+
+func (this *QAction) CheckableChanged(checkable bool) {
+	C.QAction_checkableChanged(this.h, (C.bool)(checkable))
+}
+func (this *QAction) OnCheckableChanged(slot func(checkable bool)) {
+	C.QAction_connect_checkableChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_checkableChanged
+func miqt_exec_callback_QAction_checkableChanged(cb C.intptr_t, checkable C.bool) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(checkable bool))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(checkable)
+
+	gofunc(slotval1)
+}
+
+func (this *QAction) VisibleChanged() {
+	C.QAction_visibleChanged(this.h)
+}
+func (this *QAction) OnVisibleChanged(slot func()) {
+	C.QAction_connect_visibleChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_visibleChanged
+func miqt_exec_callback_QAction_visibleChanged(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func (this *QAction) Triggered() {
+	C.QAction_triggered(this.h)
+}
+func (this *QAction) OnTriggered(slot func()) {
+	C.QAction_connect_triggered(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_triggered
+func miqt_exec_callback_QAction_triggered(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func (this *QAction) Hovered() {
+	C.QAction_hovered(this.h)
+}
+func (this *QAction) OnHovered(slot func()) {
+	C.QAction_connect_hovered(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_hovered
+func miqt_exec_callback_QAction_hovered(cb C.intptr_t) {
+	gofunc, ok := cgo.Handle(cb).Value().(func())
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	gofunc()
+}
+
+func (this *QAction) Toggled(param1 bool) {
+	C.QAction_toggled(this.h, (C.bool)(param1))
+}
+func (this *QAction) OnToggled(slot func(param1 bool)) {
+	C.QAction_connect_toggled(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_toggled
+func miqt_exec_callback_QAction_toggled(cb C.intptr_t, param1 C.bool) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(param1 bool))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(param1)
+
+	gofunc(slotval1)
+}
+
+func QAction_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAction_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAction_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAction_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAction) ShowStatusTextWithObject(object *QObject) bool {
+	return (bool)(C.QAction_showStatusTextWithObject(this.h, object.cPointer()))
+}
+
+func (this *QAction) TriggeredWithChecked(checked bool) {
+	C.QAction_triggeredWithChecked(this.h, (C.bool)(checked))
+}
+func (this *QAction) OnTriggeredWithChecked(slot func(checked bool)) {
+	C.QAction_connect_triggeredWithChecked(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QAction_triggeredWithChecked
+func miqt_exec_callback_QAction_triggeredWithChecked(cb C.intptr_t, checked C.bool) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(checked bool))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := (bool)(checked)
+
+	gofunc(slotval1)
+}
+
+// Sender can only be called from a QAction that was directly constructed.
+func (this *QAction) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QAction_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QAction that was directly constructed.
+func (this *QAction) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAction_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QAction that was directly constructed.
+func (this *QAction) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAction_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QAction that was directly constructed.
+func (this *QAction) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QAction_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+func (this *QAction) callVirtualBase_Event(param1 *QEvent) bool {
+
+	return (bool)(C.QAction_virtualbase_event(unsafe.Pointer(this.h), param1.cPointer()))
+
+}
+func (this *QAction) OnEvent(slot func(super func(param1 *QEvent) bool, param1 *QEvent) bool) {
+	ok := C.QAction_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_event
+func miqt_exec_callback_QAction_event(self *C.QAction, cb C.intptr_t, param1 *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *QEvent) bool, param1 *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQEvent(param1)
+
+	virtualReturn := gofunc((&QAction{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAction) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAction_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAction) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QAction_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_eventFilter
+func miqt_exec_callback_QAction_eventFilter(self *C.QAction, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAction{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAction) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAction_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAction) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QAction_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_timerEvent
+func miqt_exec_callback_QAction_timerEvent(self *C.QAction, 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 := newQTimerEvent(event)
+
+	gofunc((&QAction{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAction) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAction_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAction) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QAction_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_childEvent
+func miqt_exec_callback_QAction_childEvent(self *C.QAction, 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 := newQChildEvent(event)
+
+	gofunc((&QAction{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAction) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAction_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAction) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QAction_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_customEvent
+func miqt_exec_callback_QAction_customEvent(self *C.QAction, 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 := newQEvent(event)
+
+	gofunc((&QAction{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAction) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAction_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAction) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAction_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_connectNotify
+func miqt_exec_callback_QAction_connectNotify(self *C.QAction, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAction{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAction) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAction_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAction) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAction_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAction_disconnectNotify
+func miqt_exec_callback_QAction_disconnectNotify(self *C.QAction, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAction{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAction) Delete() {
+	C.QAction_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAction) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAction) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qaction.h

@@ -0,0 +1,155 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACTION_H
+#define MIQT_QT6_GEN_QACTION_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAction;
+class QActionGroup;
+class QChildEvent;
+class QEvent;
+class QFont;
+class QIcon;
+class QKeySequence;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAction QAction;
+typedef struct QActionGroup QActionGroup;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QFont QFont;
+typedef struct QIcon QIcon;
+typedef struct QKeySequence QKeySequence;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QAction* QAction_new();
+QAction* QAction_new2(struct miqt_string text);
+QAction* QAction_new3(QIcon* icon, struct miqt_string text);
+QAction* QAction_new4(QObject* parent);
+QAction* QAction_new5(struct miqt_string text, QObject* parent);
+QAction* QAction_new6(QIcon* icon, struct miqt_string text, QObject* parent);
+void QAction_virtbase(QAction* src, QObject** outptr_QObject);
+QMetaObject* QAction_metaObject(const QAction* self);
+void* QAction_metacast(QAction* self, const char* param1);
+struct miqt_string QAction_tr(const char* s);
+struct miqt_array /* of QObject* */  QAction_associatedObjects(const QAction* self);
+void QAction_setActionGroup(QAction* self, QActionGroup* group);
+QActionGroup* QAction_actionGroup(const QAction* self);
+void QAction_setIcon(QAction* self, QIcon* icon);
+QIcon* QAction_icon(const QAction* self);
+void QAction_setText(QAction* self, struct miqt_string text);
+struct miqt_string QAction_text(const QAction* self);
+void QAction_setIconText(QAction* self, struct miqt_string text);
+struct miqt_string QAction_iconText(const QAction* self);
+void QAction_setToolTip(QAction* self, struct miqt_string tip);
+struct miqt_string QAction_toolTip(const QAction* self);
+void QAction_setStatusTip(QAction* self, struct miqt_string statusTip);
+struct miqt_string QAction_statusTip(const QAction* self);
+void QAction_setWhatsThis(QAction* self, struct miqt_string what);
+struct miqt_string QAction_whatsThis(const QAction* self);
+void QAction_setPriority(QAction* self, int priority);
+int QAction_priority(const QAction* self);
+void QAction_setSeparator(QAction* self, bool b);
+bool QAction_isSeparator(const QAction* self);
+void QAction_setShortcut(QAction* self, QKeySequence* shortcut);
+QKeySequence* QAction_shortcut(const QAction* self);
+void QAction_setShortcuts(QAction* self, struct miqt_array /* of QKeySequence* */  shortcuts);
+void QAction_setShortcutsWithShortcuts(QAction* self, int shortcuts);
+struct miqt_array /* of QKeySequence* */  QAction_shortcuts(const QAction* self);
+void QAction_setShortcutContext(QAction* self, int context);
+int QAction_shortcutContext(const QAction* self);
+void QAction_setAutoRepeat(QAction* self, bool autoRepeat);
+bool QAction_autoRepeat(const QAction* self);
+void QAction_setFont(QAction* self, QFont* font);
+QFont* QAction_font(const QAction* self);
+void QAction_setCheckable(QAction* self, bool checkable);
+bool QAction_isCheckable(const QAction* self);
+QVariant* QAction_data(const QAction* self);
+void QAction_setData(QAction* self, QVariant* var);
+bool QAction_isChecked(const QAction* self);
+bool QAction_isEnabled(const QAction* self);
+bool QAction_isVisible(const QAction* self);
+void QAction_activate(QAction* self, int event);
+void QAction_setMenuRole(QAction* self, int menuRole);
+int QAction_menuRole(const QAction* self);
+void QAction_setIconVisibleInMenu(QAction* self, bool visible);
+bool QAction_isIconVisibleInMenu(const QAction* self);
+void QAction_setShortcutVisibleInContextMenu(QAction* self, bool show);
+bool QAction_isShortcutVisibleInContextMenu(const QAction* self);
+bool QAction_showStatusText(QAction* self);
+bool QAction_event(QAction* self, QEvent* param1);
+void QAction_trigger(QAction* self);
+void QAction_hover(QAction* self);
+void QAction_setChecked(QAction* self, bool checked);
+void QAction_toggle(QAction* self);
+void QAction_setEnabled(QAction* self, bool enabled);
+void QAction_resetEnabled(QAction* self);
+void QAction_setDisabled(QAction* self, bool b);
+void QAction_setVisible(QAction* self, bool visible);
+void QAction_changed(QAction* self);
+void QAction_connect_changed(QAction* self, intptr_t slot);
+void QAction_enabledChanged(QAction* self, bool enabled);
+void QAction_connect_enabledChanged(QAction* self, intptr_t slot);
+void QAction_checkableChanged(QAction* self, bool checkable);
+void QAction_connect_checkableChanged(QAction* self, intptr_t slot);
+void QAction_visibleChanged(QAction* self);
+void QAction_connect_visibleChanged(QAction* self, intptr_t slot);
+void QAction_triggered(QAction* self);
+void QAction_connect_triggered(QAction* self, intptr_t slot);
+void QAction_hovered(QAction* self);
+void QAction_connect_hovered(QAction* self, intptr_t slot);
+void QAction_toggled(QAction* self, bool param1);
+void QAction_connect_toggled(QAction* self, intptr_t slot);
+struct miqt_string QAction_tr2(const char* s, const char* c);
+struct miqt_string QAction_tr3(const char* s, const char* c, int n);
+bool QAction_showStatusTextWithObject(QAction* self, QObject* object);
+void QAction_triggeredWithChecked(QAction* self, bool checked);
+void QAction_connect_triggeredWithChecked(QAction* self, intptr_t slot);
+
+bool QAction_override_virtual_event(void* self, intptr_t slot);
+bool QAction_virtualbase_event(void* self, QEvent* param1);
+bool QAction_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAction_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAction_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAction_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAction_override_virtual_childEvent(void* self, intptr_t slot);
+void QAction_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAction_override_virtual_customEvent(void* self, intptr_t slot);
+void QAction_virtualbase_customEvent(void* self, QEvent* event);
+bool QAction_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAction_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAction_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAction_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAction_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAction_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAction_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAction_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAction_delete(QAction* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qactiongroup.cpp

@@ -0,0 +1,458 @@
+#include <QAction>
+#include <QActionGroup>
+#include <QChildEvent>
+#include <QEvent>
+#include <QIcon>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qactiongroup.h>
+#include "gen_qactiongroup.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QActionGroup_triggered(intptr_t, QAction*);
+void miqt_exec_callback_QActionGroup_hovered(intptr_t, QAction*);
+bool miqt_exec_callback_QActionGroup_event(QActionGroup*, intptr_t, QEvent*);
+bool miqt_exec_callback_QActionGroup_eventFilter(QActionGroup*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QActionGroup_timerEvent(QActionGroup*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QActionGroup_childEvent(QActionGroup*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QActionGroup_customEvent(QActionGroup*, intptr_t, QEvent*);
+void miqt_exec_callback_QActionGroup_connectNotify(QActionGroup*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QActionGroup_disconnectNotify(QActionGroup*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQActionGroup final : public QActionGroup {
+public:
+
+	MiqtVirtualQActionGroup(QObject* parent): QActionGroup(parent) {}
+
+	virtual ~MiqtVirtualQActionGroup() override = default;
+
+	// 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 QActionGroup::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QActionGroup_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QActionGroup_virtualbase_event(void* self, QEvent* 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 QActionGroup::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QActionGroup_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QActionGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QActionGroup::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QActionGroup_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QActionGroup_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QActionGroup::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QActionGroup_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QActionGroup_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QActionGroup::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QActionGroup_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QActionGroup_virtualbase_customEvent(void* self, QEvent* 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) {
+			QActionGroup::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QActionGroup_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QActionGroup_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QActionGroup::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QActionGroup_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QActionGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QActionGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QActionGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QActionGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QActionGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QActionGroup* QActionGroup_new(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQActionGroup(parent);
+}
+
+void QActionGroup_virtbase(QActionGroup* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QActionGroup_metaObject(const QActionGroup* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QActionGroup_metacast(QActionGroup* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QActionGroup_tr(const char* s) {
+	QString _ret = QActionGroup::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAction* QActionGroup_addAction(QActionGroup* self, QAction* a) {
+	return self->addAction(a);
+}
+
+QAction* QActionGroup_addActionWithText(QActionGroup* self, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return self->addAction(text_QString);
+}
+
+QAction* QActionGroup_addAction2(QActionGroup* self, QIcon* icon, struct miqt_string text) {
+	QString text_QString = QString::fromUtf8(text.data, text.len);
+	return self->addAction(*icon, text_QString);
+}
+
+void QActionGroup_removeAction(QActionGroup* self, QAction* a) {
+	self->removeAction(a);
+}
+
+struct miqt_array /* of QAction* */  QActionGroup_actions(const QActionGroup* self) {
+	QList<QAction *> _ret = self->actions();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QAction** _arr = static_cast<QAction**>(malloc(sizeof(QAction*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QAction* QActionGroup_checkedAction(const QActionGroup* self) {
+	return self->checkedAction();
+}
+
+bool QActionGroup_isExclusive(const QActionGroup* self) {
+	return self->isExclusive();
+}
+
+bool QActionGroup_isEnabled(const QActionGroup* self) {
+	return self->isEnabled();
+}
+
+bool QActionGroup_isVisible(const QActionGroup* self) {
+	return self->isVisible();
+}
+
+int QActionGroup_exclusionPolicy(const QActionGroup* self) {
+	QActionGroup::ExclusionPolicy _ret = self->exclusionPolicy();
+	return static_cast<int>(_ret);
+}
+
+void QActionGroup_setEnabled(QActionGroup* self, bool enabled) {
+	self->setEnabled(enabled);
+}
+
+void QActionGroup_setDisabled(QActionGroup* self, bool b) {
+	self->setDisabled(b);
+}
+
+void QActionGroup_setVisible(QActionGroup* self, bool visible) {
+	self->setVisible(visible);
+}
+
+void QActionGroup_setExclusive(QActionGroup* self, bool exclusive) {
+	self->setExclusive(exclusive);
+}
+
+void QActionGroup_setExclusionPolicy(QActionGroup* self, int policy) {
+	self->setExclusionPolicy(static_cast<QActionGroup::ExclusionPolicy>(policy));
+}
+
+void QActionGroup_triggered(QActionGroup* self, QAction* param1) {
+	self->triggered(param1);
+}
+
+void QActionGroup_connect_triggered(QActionGroup* self, intptr_t slot) {
+	QActionGroup::connect(self, static_cast<void (QActionGroup::*)(QAction*)>(&QActionGroup::triggered), self, [=](QAction* param1) {
+		QAction* sigval1 = param1;
+		miqt_exec_callback_QActionGroup_triggered(slot, sigval1);
+	});
+}
+
+void QActionGroup_hovered(QActionGroup* self, QAction* param1) {
+	self->hovered(param1);
+}
+
+void QActionGroup_connect_hovered(QActionGroup* self, intptr_t slot) {
+	QActionGroup::connect(self, static_cast<void (QActionGroup::*)(QAction*)>(&QActionGroup::hovered), self, [=](QAction* param1) {
+		QAction* sigval1 = param1;
+		miqt_exec_callback_QActionGroup_hovered(slot, sigval1);
+	});
+}
+
+struct miqt_string QActionGroup_tr2(const char* s, const char* c) {
+	QString _ret = QActionGroup::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QActionGroup_tr3(const char* s, const char* c, int n) {
+	QString _ret = QActionGroup::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QActionGroup_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QActionGroup_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::event(event);
+}
+
+bool QActionGroup_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QActionGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::eventFilter(watched, event);
+}
+
+bool QActionGroup_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QActionGroup_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::timerEvent(event);
+}
+
+bool QActionGroup_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QActionGroup_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::childEvent(event);
+}
+
+bool QActionGroup_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QActionGroup_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::customEvent(event);
+}
+
+bool QActionGroup_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QActionGroup_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::connectNotify(*signal);
+}
+
+bool QActionGroup_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QActionGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQActionGroup*>(self)->QActionGroup::disconnectNotify(*signal);
+}
+
+QObject* QActionGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QActionGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QActionGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QActionGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQActionGroup* self_cast = dynamic_cast<MiqtVirtualQActionGroup*>( (QActionGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QActionGroup_delete(QActionGroup* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qactiongroup.go

@@ -0,0 +1,480 @@
+package qt6
+
+/*
+
+#include "gen_qactiongroup.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QActionGroup__ExclusionPolicy int
+
+const (
+	QActionGroup__None              QActionGroup__ExclusionPolicy = 0
+	QActionGroup__Exclusive         QActionGroup__ExclusionPolicy = 1
+	QActionGroup__ExclusiveOptional QActionGroup__ExclusionPolicy = 2
+)
+
+type QActionGroup struct {
+	h *C.QActionGroup
+	*QObject
+}
+
+func (this *QActionGroup) cPointer() *C.QActionGroup {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QActionGroup) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQActionGroup constructs the type using only CGO pointers.
+func newQActionGroup(h *C.QActionGroup) *QActionGroup {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QActionGroup_virtbase(h, &outptr_QObject)
+
+	return &QActionGroup{h: h,
+		QObject: newQObject(outptr_QObject)}
+}
+
+// UnsafeNewQActionGroup constructs the type using only unsafe pointers.
+func UnsafeNewQActionGroup(h unsafe.Pointer) *QActionGroup {
+	return newQActionGroup((*C.QActionGroup)(h))
+}
+
+// NewQActionGroup constructs a new QActionGroup object.
+func NewQActionGroup(parent *QObject) *QActionGroup {
+
+	return newQActionGroup(C.QActionGroup_new(parent.cPointer()))
+}
+
+func (this *QActionGroup) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QActionGroup_metaObject(this.h))
+}
+
+func (this *QActionGroup) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QActionGroup_metacast(this.h, param1_Cstring))
+}
+
+func QActionGroup_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QActionGroup_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QActionGroup) AddAction(a *QAction) *QAction {
+	return newQAction(C.QActionGroup_addAction(this.h, a.cPointer()))
+}
+
+func (this *QActionGroup) AddActionWithText(text string) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+	return newQAction(C.QActionGroup_addActionWithText(this.h, text_ms))
+}
+
+func (this *QActionGroup) AddAction2(icon *QIcon, text string) *QAction {
+	text_ms := C.struct_miqt_string{}
+	text_ms.data = C.CString(text)
+	text_ms.len = C.size_t(len(text))
+	defer C.free(unsafe.Pointer(text_ms.data))
+	return newQAction(C.QActionGroup_addAction2(this.h, icon.cPointer(), text_ms))
+}
+
+func (this *QActionGroup) RemoveAction(a *QAction) {
+	C.QActionGroup_removeAction(this.h, a.cPointer())
+}
+
+func (this *QActionGroup) Actions() []*QAction {
+	var _ma C.struct_miqt_array = C.QActionGroup_actions(this.h)
+	_ret := make([]*QAction, int(_ma.len))
+	_outCast := (*[0xffff]*C.QAction)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = newQAction(_outCast[i])
+	}
+	return _ret
+}
+
+func (this *QActionGroup) CheckedAction() *QAction {
+	return newQAction(C.QActionGroup_checkedAction(this.h))
+}
+
+func (this *QActionGroup) IsExclusive() bool {
+	return (bool)(C.QActionGroup_isExclusive(this.h))
+}
+
+func (this *QActionGroup) IsEnabled() bool {
+	return (bool)(C.QActionGroup_isEnabled(this.h))
+}
+
+func (this *QActionGroup) IsVisible() bool {
+	return (bool)(C.QActionGroup_isVisible(this.h))
+}
+
+func (this *QActionGroup) ExclusionPolicy() QActionGroup__ExclusionPolicy {
+	return (QActionGroup__ExclusionPolicy)(C.QActionGroup_exclusionPolicy(this.h))
+}
+
+func (this *QActionGroup) SetEnabled(enabled bool) {
+	C.QActionGroup_setEnabled(this.h, (C.bool)(enabled))
+}
+
+func (this *QActionGroup) SetDisabled(b bool) {
+	C.QActionGroup_setDisabled(this.h, (C.bool)(b))
+}
+
+func (this *QActionGroup) SetVisible(visible bool) {
+	C.QActionGroup_setVisible(this.h, (C.bool)(visible))
+}
+
+func (this *QActionGroup) SetExclusive(exclusive bool) {
+	C.QActionGroup_setExclusive(this.h, (C.bool)(exclusive))
+}
+
+func (this *QActionGroup) SetExclusionPolicy(policy QActionGroup__ExclusionPolicy) {
+	C.QActionGroup_setExclusionPolicy(this.h, (C.int)(policy))
+}
+
+func (this *QActionGroup) Triggered(param1 *QAction) {
+	C.QActionGroup_triggered(this.h, param1.cPointer())
+}
+func (this *QActionGroup) OnTriggered(slot func(param1 *QAction)) {
+	C.QActionGroup_connect_triggered(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QActionGroup_triggered
+func miqt_exec_callback_QActionGroup_triggered(cb C.intptr_t, param1 *C.QAction) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(param1 *QAction))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQAction(param1)
+
+	gofunc(slotval1)
+}
+
+func (this *QActionGroup) Hovered(param1 *QAction) {
+	C.QActionGroup_hovered(this.h, param1.cPointer())
+}
+func (this *QActionGroup) OnHovered(slot func(param1 *QAction)) {
+	C.QActionGroup_connect_hovered(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QActionGroup_hovered
+func miqt_exec_callback_QActionGroup_hovered(cb C.intptr_t, param1 *C.QAction) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(param1 *QAction))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQAction(param1)
+
+	gofunc(slotval1)
+}
+
+func QActionGroup_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QActionGroup_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QActionGroup_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QActionGroup_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QActionGroup that was directly constructed.
+func (this *QActionGroup) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QActionGroup_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QActionGroup that was directly constructed.
+func (this *QActionGroup) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QActionGroup_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QActionGroup that was directly constructed.
+func (this *QActionGroup) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QActionGroup_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QActionGroup that was directly constructed.
+func (this *QActionGroup) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QActionGroup_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+func (this *QActionGroup) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QActionGroup_virtualbase_event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QActionGroup) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	ok := C.QActionGroup_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_event
+func miqt_exec_callback_QActionGroup_event(self *C.QActionGroup, 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 := newQEvent(event)
+
+	virtualReturn := gofunc((&QActionGroup{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QActionGroup) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QActionGroup_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QActionGroup) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QActionGroup_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_eventFilter
+func miqt_exec_callback_QActionGroup_eventFilter(self *C.QActionGroup, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QActionGroup{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QActionGroup) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QActionGroup_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QActionGroup) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QActionGroup_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_timerEvent
+func miqt_exec_callback_QActionGroup_timerEvent(self *C.QActionGroup, 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 := newQTimerEvent(event)
+
+	gofunc((&QActionGroup{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QActionGroup) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QActionGroup_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QActionGroup) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QActionGroup_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_childEvent
+func miqt_exec_callback_QActionGroup_childEvent(self *C.QActionGroup, 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 := newQChildEvent(event)
+
+	gofunc((&QActionGroup{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QActionGroup) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QActionGroup_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QActionGroup) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QActionGroup_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_customEvent
+func miqt_exec_callback_QActionGroup_customEvent(self *C.QActionGroup, 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 := newQEvent(event)
+
+	gofunc((&QActionGroup{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QActionGroup) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QActionGroup_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QActionGroup) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QActionGroup_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_connectNotify
+func miqt_exec_callback_QActionGroup_connectNotify(self *C.QActionGroup, 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 := newQMetaMethod(signal)
+
+	gofunc((&QActionGroup{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QActionGroup) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QActionGroup_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QActionGroup) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QActionGroup_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QActionGroup_disconnectNotify
+func miqt_exec_callback_QActionGroup_disconnectNotify(self *C.QActionGroup, 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 := newQMetaMethod(signal)
+
+	gofunc((&QActionGroup{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QActionGroup) Delete() {
+	C.QActionGroup_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QActionGroup) GoGC() {
+	runtime.SetFinalizer(this, func(this *QActionGroup) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qactiongroup.h

@@ -0,0 +1,92 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QACTIONGROUP_H
+#define MIQT_QT6_GEN_QACTIONGROUP_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAction;
+class QActionGroup;
+class QChildEvent;
+class QEvent;
+class QIcon;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+#else
+typedef struct QAction QAction;
+typedef struct QActionGroup QActionGroup;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QIcon QIcon;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QActionGroup* QActionGroup_new(QObject* parent);
+void QActionGroup_virtbase(QActionGroup* src, QObject** outptr_QObject);
+QMetaObject* QActionGroup_metaObject(const QActionGroup* self);
+void* QActionGroup_metacast(QActionGroup* self, const char* param1);
+struct miqt_string QActionGroup_tr(const char* s);
+QAction* QActionGroup_addAction(QActionGroup* self, QAction* a);
+QAction* QActionGroup_addActionWithText(QActionGroup* self, struct miqt_string text);
+QAction* QActionGroup_addAction2(QActionGroup* self, QIcon* icon, struct miqt_string text);
+void QActionGroup_removeAction(QActionGroup* self, QAction* a);
+struct miqt_array /* of QAction* */  QActionGroup_actions(const QActionGroup* self);
+QAction* QActionGroup_checkedAction(const QActionGroup* self);
+bool QActionGroup_isExclusive(const QActionGroup* self);
+bool QActionGroup_isEnabled(const QActionGroup* self);
+bool QActionGroup_isVisible(const QActionGroup* self);
+int QActionGroup_exclusionPolicy(const QActionGroup* self);
+void QActionGroup_setEnabled(QActionGroup* self, bool enabled);
+void QActionGroup_setDisabled(QActionGroup* self, bool b);
+void QActionGroup_setVisible(QActionGroup* self, bool visible);
+void QActionGroup_setExclusive(QActionGroup* self, bool exclusive);
+void QActionGroup_setExclusionPolicy(QActionGroup* self, int policy);
+void QActionGroup_triggered(QActionGroup* self, QAction* param1);
+void QActionGroup_connect_triggered(QActionGroup* self, intptr_t slot);
+void QActionGroup_hovered(QActionGroup* self, QAction* param1);
+void QActionGroup_connect_hovered(QActionGroup* self, intptr_t slot);
+struct miqt_string QActionGroup_tr2(const char* s, const char* c);
+struct miqt_string QActionGroup_tr3(const char* s, const char* c, int n);
+
+bool QActionGroup_override_virtual_event(void* self, intptr_t slot);
+bool QActionGroup_virtualbase_event(void* self, QEvent* event);
+bool QActionGroup_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QActionGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QActionGroup_override_virtual_timerEvent(void* self, intptr_t slot);
+void QActionGroup_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QActionGroup_override_virtual_childEvent(void* self, intptr_t slot);
+void QActionGroup_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QActionGroup_override_virtual_customEvent(void* self, intptr_t slot);
+void QActionGroup_virtualbase_customEvent(void* self, QEvent* event);
+bool QActionGroup_override_virtual_connectNotify(void* self, intptr_t slot);
+void QActionGroup_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QActionGroup_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QActionGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QActionGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QActionGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QActionGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QActionGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QActionGroup_delete(QActionGroup* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qanimationgroup.cpp

@@ -0,0 +1,514 @@
+#include <QAbstractAnimation>
+#include <QAnimationGroup>
+#include <QChildEvent>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qanimationgroup.h>
+#include "gen_qanimationgroup.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool miqt_exec_callback_QAnimationGroup_event(QAnimationGroup*, intptr_t, QEvent*);
+int miqt_exec_callback_QAnimationGroup_duration(const QAnimationGroup*, intptr_t);
+void miqt_exec_callback_QAnimationGroup_updateCurrentTime(QAnimationGroup*, intptr_t, int);
+void miqt_exec_callback_QAnimationGroup_updateState(QAnimationGroup*, intptr_t, int, int);
+void miqt_exec_callback_QAnimationGroup_updateDirection(QAnimationGroup*, intptr_t, int);
+bool miqt_exec_callback_QAnimationGroup_eventFilter(QAnimationGroup*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QAnimationGroup_timerEvent(QAnimationGroup*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QAnimationGroup_childEvent(QAnimationGroup*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QAnimationGroup_customEvent(QAnimationGroup*, intptr_t, QEvent*);
+void miqt_exec_callback_QAnimationGroup_connectNotify(QAnimationGroup*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QAnimationGroup_disconnectNotify(QAnimationGroup*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQAnimationGroup final : public QAnimationGroup {
+public:
+
+	MiqtVirtualQAnimationGroup(): QAnimationGroup() {}
+	MiqtVirtualQAnimationGroup(QObject* parent): QAnimationGroup(parent) {}
+
+	virtual ~MiqtVirtualQAnimationGroup() override = default;
+
+	// 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 QAnimationGroup::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QAnimationGroup_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QAnimationGroup_virtualbase_event(void* self, QEvent* event);
+
+	// 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_QAnimationGroup_duration(this, handle__duration);
+		return static_cast<int>(callback_return_value);
+	}
+
+	// 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_QAnimationGroup_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) {
+			QAnimationGroup::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_QAnimationGroup_updateState(this, handle__updateState, sigval1, sigval2);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_updateState(void* self, int newState, int 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) {
+			QAnimationGroup::updateDirection(direction);
+			return;
+		}
+
+		QAbstractAnimation::Direction direction_ret = direction;
+		int sigval1 = static_cast<int>(direction_ret);
+		miqt_exec_callback_QAnimationGroup_updateDirection(this, handle__updateDirection, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_updateDirection(void* self, int 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 QAnimationGroup::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QAnimationGroup_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QAnimationGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QAnimationGroup::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QAnimationGroup_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QAnimationGroup::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QAnimationGroup_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QAnimationGroup::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QAnimationGroup_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_customEvent(void* self, QEvent* 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) {
+			QAnimationGroup::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAnimationGroup_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QAnimationGroup::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QAnimationGroup_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QAnimationGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QAnimationGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QAnimationGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QAnimationGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QAnimationGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QAnimationGroup* QAnimationGroup_new() {
+	return new (std::nothrow) MiqtVirtualQAnimationGroup();
+}
+
+QAnimationGroup* QAnimationGroup_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQAnimationGroup(parent);
+}
+
+void QAnimationGroup_virtbase(QAnimationGroup* src, QAbstractAnimation** outptr_QAbstractAnimation) {
+	*outptr_QAbstractAnimation = static_cast<QAbstractAnimation*>(src);
+}
+
+QMetaObject* QAnimationGroup_metaObject(const QAnimationGroup* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QAnimationGroup_metacast(QAnimationGroup* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QAnimationGroup_tr(const char* s) {
+	QString _ret = QAnimationGroup::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QAbstractAnimation* QAnimationGroup_animationAt(const QAnimationGroup* self, int index) {
+	return self->animationAt(static_cast<int>(index));
+}
+
+int QAnimationGroup_animationCount(const QAnimationGroup* self) {
+	return self->animationCount();
+}
+
+int QAnimationGroup_indexOfAnimation(const QAnimationGroup* self, QAbstractAnimation* animation) {
+	return self->indexOfAnimation(animation);
+}
+
+void QAnimationGroup_addAnimation(QAnimationGroup* self, QAbstractAnimation* animation) {
+	self->addAnimation(animation);
+}
+
+void QAnimationGroup_insertAnimation(QAnimationGroup* self, int index, QAbstractAnimation* animation) {
+	self->insertAnimation(static_cast<int>(index), animation);
+}
+
+void QAnimationGroup_removeAnimation(QAnimationGroup* self, QAbstractAnimation* animation) {
+	self->removeAnimation(animation);
+}
+
+QAbstractAnimation* QAnimationGroup_takeAnimation(QAnimationGroup* self, int index) {
+	return self->takeAnimation(static_cast<int>(index));
+}
+
+void QAnimationGroup_clear(QAnimationGroup* self) {
+	self->clear();
+}
+
+struct miqt_string QAnimationGroup_tr2(const char* s, const char* c) {
+	QString _ret = QAnimationGroup::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QAnimationGroup_tr3(const char* s, const char* c, int n) {
+	QString _ret = QAnimationGroup::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QAnimationGroup_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QAnimationGroup_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::event(event);
+}
+
+bool QAnimationGroup_override_virtual_duration(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__duration = slot;
+	return true;
+}
+
+bool QAnimationGroup_override_virtual_updateCurrentTime(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__updateCurrentTime = slot;
+	return true;
+}
+
+bool QAnimationGroup_override_virtual_updateState(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__updateState = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_updateState(void* self, int newState, int oldState) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::updateState(static_cast<MiqtVirtualQAnimationGroup::State>(newState), static_cast<MiqtVirtualQAnimationGroup::State>(oldState));
+}
+
+bool QAnimationGroup_override_virtual_updateDirection(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__updateDirection = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_updateDirection(void* self, int direction) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::updateDirection(static_cast<MiqtVirtualQAnimationGroup::Direction>(direction));
+}
+
+bool QAnimationGroup_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QAnimationGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::eventFilter(watched, event);
+}
+
+bool QAnimationGroup_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::timerEvent(event);
+}
+
+bool QAnimationGroup_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::childEvent(event);
+}
+
+bool QAnimationGroup_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::customEvent(event);
+}
+
+bool QAnimationGroup_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::connectNotify(*signal);
+}
+
+bool QAnimationGroup_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QAnimationGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQAnimationGroup*>(self)->QAnimationGroup::disconnectNotify(*signal);
+}
+
+QObject* QAnimationGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QAnimationGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QAnimationGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QAnimationGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQAnimationGroup* self_cast = dynamic_cast<MiqtVirtualQAnimationGroup*>( (QAnimationGroup*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QAnimationGroup_delete(QAnimationGroup* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qanimationgroup.go

@@ -0,0 +1,489 @@
+package qt6
+
+/*
+
+#include "gen_qanimationgroup.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QAnimationGroup struct {
+	h *C.QAnimationGroup
+	*QAbstractAnimation
+}
+
+func (this *QAnimationGroup) cPointer() *C.QAnimationGroup {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAnimationGroup) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAnimationGroup constructs the type using only CGO pointers.
+func newQAnimationGroup(h *C.QAnimationGroup) *QAnimationGroup {
+	if h == nil {
+		return nil
+	}
+	var outptr_QAbstractAnimation *C.QAbstractAnimation = nil
+	C.QAnimationGroup_virtbase(h, &outptr_QAbstractAnimation)
+
+	return &QAnimationGroup{h: h,
+		QAbstractAnimation: newQAbstractAnimation(outptr_QAbstractAnimation)}
+}
+
+// UnsafeNewQAnimationGroup constructs the type using only unsafe pointers.
+func UnsafeNewQAnimationGroup(h unsafe.Pointer) *QAnimationGroup {
+	return newQAnimationGroup((*C.QAnimationGroup)(h))
+}
+
+// NewQAnimationGroup constructs a new QAnimationGroup object.
+func NewQAnimationGroup() *QAnimationGroup {
+
+	return newQAnimationGroup(C.QAnimationGroup_new())
+}
+
+// NewQAnimationGroup2 constructs a new QAnimationGroup object.
+func NewQAnimationGroup2(parent *QObject) *QAnimationGroup {
+
+	return newQAnimationGroup(C.QAnimationGroup_new2(parent.cPointer()))
+}
+
+func (this *QAnimationGroup) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QAnimationGroup_metaObject(this.h))
+}
+
+func (this *QAnimationGroup) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QAnimationGroup_metacast(this.h, param1_Cstring))
+}
+
+func QAnimationGroup_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QAnimationGroup_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAnimationGroup) AnimationAt(index int) *QAbstractAnimation {
+	return newQAbstractAnimation(C.QAnimationGroup_animationAt(this.h, (C.int)(index)))
+}
+
+func (this *QAnimationGroup) AnimationCount() int {
+	return (int)(C.QAnimationGroup_animationCount(this.h))
+}
+
+func (this *QAnimationGroup) IndexOfAnimation(animation *QAbstractAnimation) int {
+	return (int)(C.QAnimationGroup_indexOfAnimation(this.h, animation.cPointer()))
+}
+
+func (this *QAnimationGroup) AddAnimation(animation *QAbstractAnimation) {
+	C.QAnimationGroup_addAnimation(this.h, animation.cPointer())
+}
+
+func (this *QAnimationGroup) InsertAnimation(index int, animation *QAbstractAnimation) {
+	C.QAnimationGroup_insertAnimation(this.h, (C.int)(index), animation.cPointer())
+}
+
+func (this *QAnimationGroup) RemoveAnimation(animation *QAbstractAnimation) {
+	C.QAnimationGroup_removeAnimation(this.h, animation.cPointer())
+}
+
+func (this *QAnimationGroup) TakeAnimation(index int) *QAbstractAnimation {
+	return newQAbstractAnimation(C.QAnimationGroup_takeAnimation(this.h, (C.int)(index)))
+}
+
+func (this *QAnimationGroup) Clear() {
+	C.QAnimationGroup_clear(this.h)
+}
+
+func QAnimationGroup_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAnimationGroup_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QAnimationGroup_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QAnimationGroup_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QAnimationGroup that was directly constructed.
+func (this *QAnimationGroup) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QAnimationGroup_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QAnimationGroup that was directly constructed.
+func (this *QAnimationGroup) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAnimationGroup_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QAnimationGroup that was directly constructed.
+func (this *QAnimationGroup) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QAnimationGroup_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QAnimationGroup that was directly constructed.
+func (this *QAnimationGroup) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QAnimationGroup_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_Event(event *QEvent) bool {
+
+	return (bool)(C.QAnimationGroup_virtualbase_event(unsafe.Pointer(this.h), event.cPointer()))
+
+}
+func (this *QAnimationGroup) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) {
+	ok := C.QAnimationGroup_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_event
+func miqt_exec_callback_QAnimationGroup_event(self *C.QAnimationGroup, 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 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAnimationGroup{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+func (this *QAnimationGroup) OnDuration(slot func() int) {
+	ok := C.QAnimationGroup_override_virtual_duration(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_duration
+func miqt_exec_callback_QAnimationGroup_duration(self *C.QAnimationGroup, 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 *QAnimationGroup) OnUpdateCurrentTime(slot func(currentTime int)) {
+	ok := C.QAnimationGroup_override_virtual_updateCurrentTime(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_updateCurrentTime
+func miqt_exec_callback_QAnimationGroup_updateCurrentTime(self *C.QAnimationGroup, 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 *QAnimationGroup) callVirtualBase_UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
+
+	C.QAnimationGroup_virtualbase_updateState(unsafe.Pointer(this.h), (C.int)(newState), (C.int)(oldState))
+
+}
+func (this *QAnimationGroup) OnUpdateState(slot func(super func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State), newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
+	ok := C.QAnimationGroup_override_virtual_updateState(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_updateState
+func miqt_exec_callback_QAnimationGroup_updateState(self *C.QAnimationGroup, 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((&QAnimationGroup{h: self}).callVirtualBase_UpdateState, slotval1, slotval2)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_UpdateDirection(direction QAbstractAnimation__Direction) {
+
+	C.QAnimationGroup_virtualbase_updateDirection(unsafe.Pointer(this.h), (C.int)(direction))
+
+}
+func (this *QAnimationGroup) OnUpdateDirection(slot func(super func(direction QAbstractAnimation__Direction), direction QAbstractAnimation__Direction)) {
+	ok := C.QAnimationGroup_override_virtual_updateDirection(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_updateDirection
+func miqt_exec_callback_QAnimationGroup_updateDirection(self *C.QAnimationGroup, 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((&QAnimationGroup{h: self}).callVirtualBase_UpdateDirection, slotval1)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QAnimationGroup_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QAnimationGroup) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QAnimationGroup_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_eventFilter
+func miqt_exec_callback_QAnimationGroup_eventFilter(self *C.QAnimationGroup, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QAnimationGroup{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QAnimationGroup_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAnimationGroup) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QAnimationGroup_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_timerEvent
+func miqt_exec_callback_QAnimationGroup_timerEvent(self *C.QAnimationGroup, 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 := newQTimerEvent(event)
+
+	gofunc((&QAnimationGroup{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QAnimationGroup_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAnimationGroup) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QAnimationGroup_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_childEvent
+func miqt_exec_callback_QAnimationGroup_childEvent(self *C.QAnimationGroup, 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 := newQChildEvent(event)
+
+	gofunc((&QAnimationGroup{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QAnimationGroup_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QAnimationGroup) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QAnimationGroup_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_customEvent
+func miqt_exec_callback_QAnimationGroup_customEvent(self *C.QAnimationGroup, 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 := newQEvent(event)
+
+	gofunc((&QAnimationGroup{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QAnimationGroup_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAnimationGroup) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAnimationGroup_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_connectNotify
+func miqt_exec_callback_QAnimationGroup_connectNotify(self *C.QAnimationGroup, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAnimationGroup{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QAnimationGroup) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QAnimationGroup_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QAnimationGroup) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QAnimationGroup_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QAnimationGroup_disconnectNotify
+func miqt_exec_callback_QAnimationGroup_disconnectNotify(self *C.QAnimationGroup, 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 := newQMetaMethod(signal)
+
+	gofunc((&QAnimationGroup{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QAnimationGroup) Delete() {
+	C.QAnimationGroup_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAnimationGroup) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAnimationGroup) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qanimationgroup.h

@@ -0,0 +1,89 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QANIMATIONGROUP_H
+#define MIQT_QT6_GEN_QANIMATIONGROUP_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractAnimation;
+class QAnimationGroup;
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QTimerEvent;
+#else
+typedef struct QAbstractAnimation QAbstractAnimation;
+typedef struct QAnimationGroup QAnimationGroup;
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QAnimationGroup* QAnimationGroup_new();
+QAnimationGroup* QAnimationGroup_new2(QObject* parent);
+void QAnimationGroup_virtbase(QAnimationGroup* src, QAbstractAnimation** outptr_QAbstractAnimation);
+QMetaObject* QAnimationGroup_metaObject(const QAnimationGroup* self);
+void* QAnimationGroup_metacast(QAnimationGroup* self, const char* param1);
+struct miqt_string QAnimationGroup_tr(const char* s);
+QAbstractAnimation* QAnimationGroup_animationAt(const QAnimationGroup* self, int index);
+int QAnimationGroup_animationCount(const QAnimationGroup* self);
+int QAnimationGroup_indexOfAnimation(const QAnimationGroup* self, QAbstractAnimation* animation);
+void QAnimationGroup_addAnimation(QAnimationGroup* self, QAbstractAnimation* animation);
+void QAnimationGroup_insertAnimation(QAnimationGroup* self, int index, QAbstractAnimation* animation);
+void QAnimationGroup_removeAnimation(QAnimationGroup* self, QAbstractAnimation* animation);
+QAbstractAnimation* QAnimationGroup_takeAnimation(QAnimationGroup* self, int index);
+void QAnimationGroup_clear(QAnimationGroup* self);
+bool QAnimationGroup_event(QAnimationGroup* self, QEvent* event);
+struct miqt_string QAnimationGroup_tr2(const char* s, const char* c);
+struct miqt_string QAnimationGroup_tr3(const char* s, const char* c, int n);
+
+bool QAnimationGroup_override_virtual_event(void* self, intptr_t slot);
+bool QAnimationGroup_virtualbase_event(void* self, QEvent* event);
+bool QAnimationGroup_override_virtual_duration(void* self, intptr_t slot);
+int QAnimationGroup_virtualbase_duration(const void* self);
+bool QAnimationGroup_override_virtual_updateCurrentTime(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_updateCurrentTime(void* self, int currentTime);
+bool QAnimationGroup_override_virtual_updateState(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_updateState(void* self, int newState, int oldState);
+bool QAnimationGroup_override_virtual_updateDirection(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_updateDirection(void* self, int direction);
+bool QAnimationGroup_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QAnimationGroup_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QAnimationGroup_override_virtual_timerEvent(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QAnimationGroup_override_virtual_childEvent(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QAnimationGroup_override_virtual_customEvent(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_customEvent(void* self, QEvent* event);
+bool QAnimationGroup_override_virtual_connectNotify(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QAnimationGroup_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QAnimationGroup_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QAnimationGroup_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QAnimationGroup_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QAnimationGroup_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QAnimationGroup_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QAnimationGroup_delete(QAnimationGroup* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qanystringview.cpp

@@ -0,0 +1,105 @@
+#include <QAnyStringView>
+#include <QByteArray>
+#include <QChar>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qanystringview.h>
+#include "gen_qanystringview.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QAnyStringView* QAnyStringView_new() {
+	return new (std::nothrow) QAnyStringView();
+}
+
+QAnyStringView* QAnyStringView_new2(struct miqt_string str) {
+	QByteArray str_QByteArray(str.data, str.len);
+	return new (std::nothrow) QAnyStringView(str_QByteArray);
+}
+
+QAnyStringView* QAnyStringView_new3(struct miqt_string str) {
+	QString str_QString = QString::fromUtf8(str.data, str.len);
+	return new (std::nothrow) QAnyStringView(str_QString);
+}
+
+QAnyStringView* QAnyStringView_new4(QChar* c) {
+	return new (std::nothrow) QAnyStringView(*c);
+}
+
+QAnyStringView* QAnyStringView_new5(QAnyStringView* param1) {
+	return new (std::nothrow) QAnyStringView(*param1);
+}
+
+struct miqt_string QAnyStringView_toString(const QAnyStringView* self) {
+	QString _ret = self->toString();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+ptrdiff_t QAnyStringView_size(const QAnyStringView* self) {
+	qsizetype _ret = self->size();
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+const void* QAnyStringView_data(const QAnyStringView* self) {
+	return (const void*) self->data();
+}
+
+int QAnyStringView_compare(QAnyStringView* lhs, QAnyStringView* rhs) {
+	return QAnyStringView::compare(*lhs, *rhs);
+}
+
+bool QAnyStringView_equal(QAnyStringView* lhs, QAnyStringView* rhs) {
+	return QAnyStringView::equal(*lhs, *rhs);
+}
+
+QChar* QAnyStringView_front(const QAnyStringView* self) {
+	return new QChar(self->front());
+}
+
+QChar* QAnyStringView_back(const QAnyStringView* self) {
+	return new QChar(self->back());
+}
+
+bool QAnyStringView_empty(const QAnyStringView* self) {
+	return self->empty();
+}
+
+ptrdiff_t QAnyStringView_sizeBytes(const QAnyStringView* self) {
+	qsizetype _ret = self->size_bytes();
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+bool QAnyStringView_isNull(const QAnyStringView* self) {
+	return self->isNull();
+}
+
+bool QAnyStringView_isEmpty(const QAnyStringView* self) {
+	return self->isEmpty();
+}
+
+ptrdiff_t QAnyStringView_length(const QAnyStringView* self) {
+	qsizetype _ret = self->length();
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+int QAnyStringView_compare2(QAnyStringView* lhs, QAnyStringView* rhs, int cs) {
+	return QAnyStringView::compare(*lhs, *rhs, static_cast<Qt::CaseSensitivity>(cs));
+}
+
+void QAnyStringView_delete(QAnyStringView* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qanystringview.go

@@ -0,0 +1,160 @@
+package qt6
+
+/*
+
+#include "gen_qanystringview.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QAnyStringView struct {
+	h *C.QAnyStringView
+}
+
+func (this *QAnyStringView) cPointer() *C.QAnyStringView {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QAnyStringView) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQAnyStringView constructs the type using only CGO pointers.
+func newQAnyStringView(h *C.QAnyStringView) *QAnyStringView {
+	if h == nil {
+		return nil
+	}
+
+	return &QAnyStringView{h: h}
+}
+
+// UnsafeNewQAnyStringView constructs the type using only unsafe pointers.
+func UnsafeNewQAnyStringView(h unsafe.Pointer) *QAnyStringView {
+	return newQAnyStringView((*C.QAnyStringView)(h))
+}
+
+// NewQAnyStringView constructs a new QAnyStringView object.
+func NewQAnyStringView() *QAnyStringView {
+
+	return newQAnyStringView(C.QAnyStringView_new())
+}
+
+// NewQAnyStringView2 constructs a new QAnyStringView object.
+func NewQAnyStringView2(str []byte) *QAnyStringView {
+	str_alias := C.struct_miqt_string{}
+	if len(str) > 0 {
+		str_alias.data = (*C.char)(unsafe.Pointer(&str[0]))
+	} else {
+		str_alias.data = (*C.char)(unsafe.Pointer(nil))
+	}
+	str_alias.len = C.size_t(len(str))
+
+	return newQAnyStringView(C.QAnyStringView_new2(str_alias))
+}
+
+// NewQAnyStringView3 constructs a new QAnyStringView object.
+func NewQAnyStringView3(str string) *QAnyStringView {
+	str_ms := C.struct_miqt_string{}
+	str_ms.data = C.CString(str)
+	str_ms.len = C.size_t(len(str))
+	defer C.free(unsafe.Pointer(str_ms.data))
+
+	return newQAnyStringView(C.QAnyStringView_new3(str_ms))
+}
+
+// NewQAnyStringView4 constructs a new QAnyStringView object.
+func NewQAnyStringView4(c *QChar) *QAnyStringView {
+
+	return newQAnyStringView(C.QAnyStringView_new4(c.cPointer()))
+}
+
+// NewQAnyStringView5 constructs a new QAnyStringView object.
+func NewQAnyStringView5(param1 *QAnyStringView) *QAnyStringView {
+
+	return newQAnyStringView(C.QAnyStringView_new5(param1.cPointer()))
+}
+
+func (this *QAnyStringView) ToString() string {
+	var _ms C.struct_miqt_string = C.QAnyStringView_toString(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QAnyStringView) Size() int64 {
+	return (int64)(C.QAnyStringView_size(this.h))
+}
+
+func (this *QAnyStringView) Data() unsafe.Pointer {
+	return (unsafe.Pointer)(C.QAnyStringView_data(this.h))
+}
+
+func QAnyStringView_Compare(lhs QAnyStringView, rhs QAnyStringView) int {
+	return (int)(C.QAnyStringView_compare(lhs.cPointer(), rhs.cPointer()))
+}
+
+func QAnyStringView_Equal(lhs QAnyStringView, rhs QAnyStringView) bool {
+	return (bool)(C.QAnyStringView_equal(lhs.cPointer(), rhs.cPointer()))
+}
+
+func (this *QAnyStringView) Front() *QChar {
+	_goptr := newQChar(C.QAnyStringView_front(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAnyStringView) Back() *QChar {
+	_goptr := newQChar(C.QAnyStringView_back(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QAnyStringView) Empty() bool {
+	return (bool)(C.QAnyStringView_empty(this.h))
+}
+
+func (this *QAnyStringView) SizeBytes() int64 {
+	return (int64)(C.QAnyStringView_sizeBytes(this.h))
+}
+
+func (this *QAnyStringView) IsNull() bool {
+	return (bool)(C.QAnyStringView_isNull(this.h))
+}
+
+func (this *QAnyStringView) IsEmpty() bool {
+	return (bool)(C.QAnyStringView_isEmpty(this.h))
+}
+
+func (this *QAnyStringView) Length() int64 {
+	return (int64)(C.QAnyStringView_length(this.h))
+}
+
+func QAnyStringView_Compare2(lhs QAnyStringView, rhs QAnyStringView, cs CaseSensitivity) int {
+	return (int)(C.QAnyStringView_compare2(lhs.cPointer(), rhs.cPointer(), (C.int)(cs)))
+}
+
+// Delete this object from C++ memory.
+func (this *QAnyStringView) Delete() {
+	C.QAnyStringView_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QAnyStringView) GoGC() {
+	runtime.SetFinalizer(this, func(this *QAnyStringView) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qanystringview.h

@@ -0,0 +1,50 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QANYSTRINGVIEW_H
+#define MIQT_QT6_GEN_QANYSTRINGVIEW_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAnyStringView;
+class QChar;
+#else
+typedef struct QAnyStringView QAnyStringView;
+typedef struct QChar QChar;
+#endif
+
+QAnyStringView* QAnyStringView_new();
+QAnyStringView* QAnyStringView_new2(struct miqt_string str);
+QAnyStringView* QAnyStringView_new3(struct miqt_string str);
+QAnyStringView* QAnyStringView_new4(QChar* c);
+QAnyStringView* QAnyStringView_new5(QAnyStringView* param1);
+struct miqt_string QAnyStringView_toString(const QAnyStringView* self);
+ptrdiff_t QAnyStringView_size(const QAnyStringView* self);
+const void* QAnyStringView_data(const QAnyStringView* self);
+int QAnyStringView_compare(QAnyStringView* lhs, QAnyStringView* rhs);
+bool QAnyStringView_equal(QAnyStringView* lhs, QAnyStringView* rhs);
+QChar* QAnyStringView_front(const QAnyStringView* self);
+QChar* QAnyStringView_back(const QAnyStringView* self);
+bool QAnyStringView_empty(const QAnyStringView* self);
+ptrdiff_t QAnyStringView_sizeBytes(const QAnyStringView* self);
+bool QAnyStringView_isNull(const QAnyStringView* self);
+bool QAnyStringView_isEmpty(const QAnyStringView* self);
+ptrdiff_t QAnyStringView_length(const QAnyStringView* self);
+int QAnyStringView_compare2(QAnyStringView* lhs, QAnyStringView* rhs, int cs);
+
+void QAnyStringView_delete(QAnyStringView* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qapplication.cpp

@@ -0,0 +1,657 @@
+#include <QApplication>
+#include <QChildEvent>
+#include <QCoreApplication>
+#include <QEvent>
+#include <QFont>
+#include <QFontMetrics>
+#include <QGuiApplication>
+#include <QList>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QPalette>
+#include <QPoint>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QStyle>
+#include <QTimerEvent>
+#include <QWidget>
+#include <qapplication.h>
+#include "gen_qapplication.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void miqt_exec_callback_QApplication_focusChanged(intptr_t, QWidget*, QWidget*);
+bool miqt_exec_callback_QApplication_notify(QApplication*, intptr_t, QObject*, QEvent*);
+bool miqt_exec_callback_QApplication_event(QApplication*, intptr_t, QEvent*);
+bool miqt_exec_callback_QApplication_eventFilter(QApplication*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QApplication_timerEvent(QApplication*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QApplication_childEvent(QApplication*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QApplication_customEvent(QApplication*, intptr_t, QEvent*);
+void miqt_exec_callback_QApplication_connectNotify(QApplication*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QApplication_disconnectNotify(QApplication*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQApplication final : public QApplication {
+public:
+
+	MiqtVirtualQApplication(int& argc, char** argv): QApplication(argc, argv) {}
+	MiqtVirtualQApplication(int& argc, char** argv, int param3): QApplication(argc, argv, param3) {}
+
+	virtual ~MiqtVirtualQApplication() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__notify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool notify(QObject* param1, QEvent* param2) override {
+		if (handle__notify == 0) {
+			return QApplication::notify(param1, param2);
+		}
+
+		QObject* sigval1 = param1;
+		QEvent* sigval2 = param2;
+		bool callback_return_value = miqt_exec_callback_QApplication_notify(this, handle__notify, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QApplication_virtualbase_notify(void* self, QObject* param1, QEvent* param2);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* param1) override {
+		if (handle__event == 0) {
+			return QApplication::event(param1);
+		}
+
+		QEvent* sigval1 = param1;
+		bool callback_return_value = miqt_exec_callback_QApplication_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QApplication_virtualbase_event(void* self, QEvent* param1);
+
+	// 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 QApplication::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QApplication_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QApplication_virtualbase_eventFilter(void* self, QObject* watched, QEvent* 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) {
+			QApplication::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QApplication_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QApplication_virtualbase_timerEvent(void* self, QTimerEvent* 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) {
+			QApplication::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QApplication_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QApplication_virtualbase_childEvent(void* self, QChildEvent* 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) {
+			QApplication::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QApplication_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QApplication_virtualbase_customEvent(void* self, QEvent* 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) {
+			QApplication::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QApplication_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QApplication_virtualbase_connectNotify(void* self, QMetaMethod* 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) {
+			QApplication::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QApplication_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QApplication_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend void* QApplication_protectedbase_resolveInterface(bool* _dynamic_cast_ok, const void* self, const char* name, int revision);
+	friend QObject* QApplication_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QApplication_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QApplication_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QApplication_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QApplication* QApplication_new(int* argc, char** argv) {
+	return new (std::nothrow) MiqtVirtualQApplication(static_cast<int&>(*argc), argv);
+}
+
+QApplication* QApplication_new2(int* argc, char** argv, int param3) {
+	return new (std::nothrow) MiqtVirtualQApplication(static_cast<int&>(*argc), argv, static_cast<int>(param3));
+}
+
+void QApplication_virtbase(QApplication* src, QGuiApplication** outptr_QGuiApplication) {
+	*outptr_QGuiApplication = static_cast<QGuiApplication*>(src);
+}
+
+QMetaObject* QApplication_metaObject(const QApplication* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QApplication_metacast(QApplication* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QApplication_tr(const char* s) {
+	QString _ret = QApplication::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QStyle* QApplication_style() {
+	return QApplication::style();
+}
+
+void QApplication_setStyle(QStyle* style) {
+	QApplication::setStyle(style);
+}
+
+QStyle* QApplication_setStyleWithStyle(struct miqt_string style) {
+	QString style_QString = QString::fromUtf8(style.data, style.len);
+	return QApplication::setStyle(style_QString);
+}
+
+QPalette* QApplication_palette(QWidget* param1) {
+	return new QPalette(QApplication::palette(param1));
+}
+
+QPalette* QApplication_paletteWithClassName(const char* className) {
+	return new QPalette(QApplication::palette(className));
+}
+
+void QApplication_setPalette(QPalette* param1) {
+	QApplication::setPalette(*param1);
+}
+
+QFont* QApplication_font() {
+	return new QFont(QApplication::font());
+}
+
+QFont* QApplication_fontWithQWidget(QWidget* param1) {
+	return new QFont(QApplication::font(param1));
+}
+
+QFont* QApplication_fontWithClassName(const char* className) {
+	return new QFont(QApplication::font(className));
+}
+
+void QApplication_setFont(QFont* param1) {
+	QApplication::setFont(*param1);
+}
+
+QFontMetrics* QApplication_fontMetrics() {
+	return new QFontMetrics(QApplication::fontMetrics());
+}
+
+struct miqt_array /* of QWidget* */  QApplication_allWidgets() {
+	QWidgetList _ret = QApplication::allWidgets();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QWidget** _arr = static_cast<QWidget**>(malloc(sizeof(QWidget*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+struct miqt_array /* of QWidget* */  QApplication_topLevelWidgets() {
+	QWidgetList _ret = QApplication::topLevelWidgets();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QWidget** _arr = static_cast<QWidget**>(malloc(sizeof(QWidget*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = _ret[i];
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QWidget* QApplication_activePopupWidget() {
+	return QApplication::activePopupWidget();
+}
+
+QWidget* QApplication_activeModalWidget() {
+	return QApplication::activeModalWidget();
+}
+
+QWidget* QApplication_focusWidget() {
+	return QApplication::focusWidget();
+}
+
+QWidget* QApplication_activeWindow() {
+	return QApplication::activeWindow();
+}
+
+void QApplication_setActiveWindow(QWidget* act) {
+	QApplication::setActiveWindow(act);
+}
+
+QWidget* QApplication_widgetAt(QPoint* p) {
+	return QApplication::widgetAt(*p);
+}
+
+QWidget* QApplication_widgetAt2(int x, int y) {
+	return QApplication::widgetAt(static_cast<int>(x), static_cast<int>(y));
+}
+
+QWidget* QApplication_topLevelAt(QPoint* p) {
+	return QApplication::topLevelAt(*p);
+}
+
+QWidget* QApplication_topLevelAt2(int x, int y) {
+	return QApplication::topLevelAt(static_cast<int>(x), static_cast<int>(y));
+}
+
+void QApplication_beep() {
+	QApplication::beep();
+}
+
+void QApplication_alert(QWidget* widget) {
+	QApplication::alert(widget);
+}
+
+void QApplication_setCursorFlashTime(int cursorFlashTime) {
+	QApplication::setCursorFlashTime(static_cast<int>(cursorFlashTime));
+}
+
+int QApplication_cursorFlashTime() {
+	return QApplication::cursorFlashTime();
+}
+
+void QApplication_setDoubleClickInterval(int doubleClickInterval) {
+	QApplication::setDoubleClickInterval(static_cast<int>(doubleClickInterval));
+}
+
+int QApplication_doubleClickInterval() {
+	return QApplication::doubleClickInterval();
+}
+
+void QApplication_setKeyboardInputInterval(int keyboardInputInterval) {
+	QApplication::setKeyboardInputInterval(static_cast<int>(keyboardInputInterval));
+}
+
+int QApplication_keyboardInputInterval() {
+	return QApplication::keyboardInputInterval();
+}
+
+void QApplication_setWheelScrollLines(int wheelScrollLines) {
+	QApplication::setWheelScrollLines(static_cast<int>(wheelScrollLines));
+}
+
+int QApplication_wheelScrollLines() {
+	return QApplication::wheelScrollLines();
+}
+
+void QApplication_setStartDragTime(int ms) {
+	QApplication::setStartDragTime(static_cast<int>(ms));
+}
+
+int QApplication_startDragTime() {
+	return QApplication::startDragTime();
+}
+
+void QApplication_setStartDragDistance(int l) {
+	QApplication::setStartDragDistance(static_cast<int>(l));
+}
+
+int QApplication_startDragDistance() {
+	return QApplication::startDragDistance();
+}
+
+bool QApplication_isEffectEnabled(int param1) {
+	return QApplication::isEffectEnabled(static_cast<Qt::UIEffect>(param1));
+}
+
+void QApplication_setEffectEnabled(int param1) {
+	QApplication::setEffectEnabled(static_cast<Qt::UIEffect>(param1));
+}
+
+int QApplication_exec() {
+	return QApplication::exec();
+}
+
+bool QApplication_notify(QApplication* self, QObject* param1, QEvent* param2) {
+	return self->notify(param1, param2);
+}
+
+void QApplication_focusChanged(QApplication* self, QWidget* old, QWidget* now) {
+	self->focusChanged(old, now);
+}
+
+void QApplication_connect_focusChanged(QApplication* self, intptr_t slot) {
+	QApplication::connect(self, static_cast<void (QApplication::*)(QWidget*, QWidget*)>(&QApplication::focusChanged), self, [=](QWidget* old, QWidget* now) {
+		QWidget* sigval1 = old;
+		QWidget* sigval2 = now;
+		miqt_exec_callback_QApplication_focusChanged(slot, sigval1, sigval2);
+	});
+}
+
+struct miqt_string QApplication_styleSheet(const QApplication* self) {
+	QString _ret = self->styleSheet();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QApplication_setStyleSheet(QApplication* self, struct miqt_string sheet) {
+	QString sheet_QString = QString::fromUtf8(sheet.data, sheet.len);
+	self->setStyleSheet(sheet_QString);
+}
+
+void QApplication_setAutoSipEnabled(QApplication* self, const bool enabled) {
+	self->setAutoSipEnabled(enabled);
+}
+
+bool QApplication_autoSipEnabled(const QApplication* self) {
+	return self->autoSipEnabled();
+}
+
+void QApplication_closeAllWindows() {
+	QApplication::closeAllWindows();
+}
+
+void QApplication_aboutQt() {
+	QApplication::aboutQt();
+}
+
+struct miqt_string QApplication_tr2(const char* s, const char* c) {
+	QString _ret = QApplication::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QApplication_tr3(const char* s, const char* c, int n) {
+	QString _ret = QApplication::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QApplication_setPalette2(QPalette* param1, const char* className) {
+	QApplication::setPalette(*param1, className);
+}
+
+void QApplication_setFont2(QFont* param1, const char* className) {
+	QApplication::setFont(*param1, className);
+}
+
+void QApplication_alert2(QWidget* widget, int duration) {
+	QApplication::alert(widget, static_cast<int>(duration));
+}
+
+void QApplication_setEffectEnabled2(int param1, bool enable) {
+	QApplication::setEffectEnabled(static_cast<Qt::UIEffect>(param1), enable);
+}
+
+bool QApplication_override_virtual_notify(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__notify = slot;
+	return true;
+}
+
+bool QApplication_virtualbase_notify(void* self, QObject* param1, QEvent* param2) {
+	return static_cast<MiqtVirtualQApplication*>(self)->QApplication::notify(param1, param2);
+}
+
+bool QApplication_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QApplication_virtualbase_event(void* self, QEvent* param1) {
+	return static_cast<MiqtVirtualQApplication*>(self)->QApplication::event(param1);
+}
+
+bool QApplication_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QApplication_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQApplication*>(self)->QApplication::eventFilter(watched, event);
+}
+
+bool QApplication_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QApplication_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQApplication*>(self)->QApplication::timerEvent(event);
+}
+
+bool QApplication_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QApplication_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQApplication*>(self)->QApplication::childEvent(event);
+}
+
+bool QApplication_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QApplication_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQApplication*>(self)->QApplication::customEvent(event);
+}
+
+bool QApplication_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QApplication_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQApplication*>(self)->QApplication::connectNotify(*signal);
+}
+
+bool QApplication_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QApplication_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQApplication*>(self)->QApplication::disconnectNotify(*signal);
+}
+
+void* QApplication_protectedbase_resolveInterface(bool* _dynamic_cast_ok, const void* self, const char* name, int revision) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->resolveInterface(name, static_cast<int>(revision));
+}
+
+QObject* QApplication_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QApplication_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QApplication_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QApplication_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQApplication* self_cast = dynamic_cast<MiqtVirtualQApplication*>( (QApplication*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QApplication_delete(QApplication* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qapplication.go

@@ -0,0 +1,693 @@
+package qt6
+
+/*
+
+#include "gen_qapplication.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QApplication struct {
+	h *C.QApplication
+	*QGuiApplication
+}
+
+func (this *QApplication) cPointer() *C.QApplication {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QApplication) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQApplication constructs the type using only CGO pointers.
+func newQApplication(h *C.QApplication) *QApplication {
+	if h == nil {
+		return nil
+	}
+	var outptr_QGuiApplication *C.QGuiApplication = nil
+	C.QApplication_virtbase(h, &outptr_QGuiApplication)
+
+	return &QApplication{h: h,
+		QGuiApplication: newQGuiApplication(outptr_QGuiApplication)}
+}
+
+// UnsafeNewQApplication constructs the type using only unsafe pointers.
+func UnsafeNewQApplication(h unsafe.Pointer) *QApplication {
+	return newQApplication((*C.QApplication)(h))
+}
+
+// NewQApplication constructs a new QApplication object.
+func NewQApplication(args []string) *QApplication {
+	// Convert []string to long-lived int& argc, char** argv, never call free()
+	argc := (*C.int)(C.malloc(8))
+	*argc = C.int(len(args))
+	argv := (*[0xffff]*C.char)(C.malloc(C.size_t(8 * len(args))))
+	for i := range args {
+		argv[i] = C.CString(args[i])
+	}
+
+	runtime.LockOSThread() // Prevent Go from migrating the main Qt thread
+
+	return newQApplication(C.QApplication_new(argc, &argv[0]))
+}
+
+// NewQApplication2 constructs a new QApplication object.
+func NewQApplication2(args []string, param3 int) *QApplication {
+	// Convert []string to long-lived int& argc, char** argv, never call free()
+	argc := (*C.int)(C.malloc(8))
+	*argc = C.int(len(args))
+	argv := (*[0xffff]*C.char)(C.malloc(C.size_t(8 * len(args))))
+	for i := range args {
+		argv[i] = C.CString(args[i])
+	}
+
+	runtime.LockOSThread() // Prevent Go from migrating the main Qt thread
+
+	return newQApplication(C.QApplication_new2(argc, &argv[0], (C.int)(param3)))
+}
+
+func (this *QApplication) MetaObject() *QMetaObject {
+	return newQMetaObject(C.QApplication_metaObject(this.h))
+}
+
+func (this *QApplication) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QApplication_metacast(this.h, param1_Cstring))
+}
+
+func QApplication_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QApplication_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QApplication_Style() *QStyle {
+	return newQStyle(C.QApplication_style())
+}
+
+func QApplication_SetStyle(style *QStyle) {
+	C.QApplication_setStyle(style.cPointer())
+}
+
+func QApplication_SetStyleWithStyle(style string) *QStyle {
+	style_ms := C.struct_miqt_string{}
+	style_ms.data = C.CString(style)
+	style_ms.len = C.size_t(len(style))
+	defer C.free(unsafe.Pointer(style_ms.data))
+	return newQStyle(C.QApplication_setStyleWithStyle(style_ms))
+}
+
+func QApplication_Palette(param1 *QWidget) *QPalette {
+	_goptr := newQPalette(C.QApplication_palette(param1.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_PaletteWithClassName(className string) *QPalette {
+	className_Cstring := C.CString(className)
+	defer C.free(unsafe.Pointer(className_Cstring))
+	_goptr := newQPalette(C.QApplication_paletteWithClassName(className_Cstring))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_SetPalette(param1 *QPalette) {
+	C.QApplication_setPalette(param1.cPointer())
+}
+
+func QApplication_Font() *QFont {
+	_goptr := newQFont(C.QApplication_font())
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_FontWithQWidget(param1 *QWidget) *QFont {
+	_goptr := newQFont(C.QApplication_fontWithQWidget(param1.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_FontWithClassName(className string) *QFont {
+	className_Cstring := C.CString(className)
+	defer C.free(unsafe.Pointer(className_Cstring))
+	_goptr := newQFont(C.QApplication_fontWithClassName(className_Cstring))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_SetFont(param1 *QFont) {
+	C.QApplication_setFont(param1.cPointer())
+}
+
+func QApplication_FontMetrics() *QFontMetrics {
+	_goptr := newQFontMetrics(C.QApplication_fontMetrics())
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QApplication_AllWidgets() []*QWidget {
+	var _ma C.struct_miqt_array = C.QApplication_allWidgets()
+	_ret := make([]*QWidget, int(_ma.len))
+	_outCast := (*[0xffff]*C.QWidget)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = newQWidget(_outCast[i])
+	}
+	return _ret
+}
+
+func QApplication_TopLevelWidgets() []*QWidget {
+	var _ma C.struct_miqt_array = C.QApplication_topLevelWidgets()
+	_ret := make([]*QWidget, int(_ma.len))
+	_outCast := (*[0xffff]*C.QWidget)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_ret[i] = newQWidget(_outCast[i])
+	}
+	return _ret
+}
+
+func QApplication_ActivePopupWidget() *QWidget {
+	return newQWidget(C.QApplication_activePopupWidget())
+}
+
+func QApplication_ActiveModalWidget() *QWidget {
+	return newQWidget(C.QApplication_activeModalWidget())
+}
+
+func QApplication_FocusWidget() *QWidget {
+	return newQWidget(C.QApplication_focusWidget())
+}
+
+func QApplication_ActiveWindow() *QWidget {
+	return newQWidget(C.QApplication_activeWindow())
+}
+
+func QApplication_SetActiveWindow(act *QWidget) {
+	C.QApplication_setActiveWindow(act.cPointer())
+}
+
+func QApplication_WidgetAt(p *QPoint) *QWidget {
+	return newQWidget(C.QApplication_widgetAt(p.cPointer()))
+}
+
+func QApplication_WidgetAt2(x int, y int) *QWidget {
+	return newQWidget(C.QApplication_widgetAt2((C.int)(x), (C.int)(y)))
+}
+
+func QApplication_TopLevelAt(p *QPoint) *QWidget {
+	return newQWidget(C.QApplication_topLevelAt(p.cPointer()))
+}
+
+func QApplication_TopLevelAt2(x int, y int) *QWidget {
+	return newQWidget(C.QApplication_topLevelAt2((C.int)(x), (C.int)(y)))
+}
+
+func QApplication_Beep() {
+	C.QApplication_beep()
+}
+
+func QApplication_Alert(widget *QWidget) {
+	C.QApplication_alert(widget.cPointer())
+}
+
+func QApplication_SetCursorFlashTime(cursorFlashTime int) {
+	C.QApplication_setCursorFlashTime((C.int)(cursorFlashTime))
+}
+
+func QApplication_CursorFlashTime() int {
+	return (int)(C.QApplication_cursorFlashTime())
+}
+
+func QApplication_SetDoubleClickInterval(doubleClickInterval int) {
+	C.QApplication_setDoubleClickInterval((C.int)(doubleClickInterval))
+}
+
+func QApplication_DoubleClickInterval() int {
+	return (int)(C.QApplication_doubleClickInterval())
+}
+
+func QApplication_SetKeyboardInputInterval(keyboardInputInterval int) {
+	C.QApplication_setKeyboardInputInterval((C.int)(keyboardInputInterval))
+}
+
+func QApplication_KeyboardInputInterval() int {
+	return (int)(C.QApplication_keyboardInputInterval())
+}
+
+func QApplication_SetWheelScrollLines(wheelScrollLines int) {
+	C.QApplication_setWheelScrollLines((C.int)(wheelScrollLines))
+}
+
+func QApplication_WheelScrollLines() int {
+	return (int)(C.QApplication_wheelScrollLines())
+}
+
+func QApplication_SetStartDragTime(ms int) {
+	C.QApplication_setStartDragTime((C.int)(ms))
+}
+
+func QApplication_StartDragTime() int {
+	return (int)(C.QApplication_startDragTime())
+}
+
+func QApplication_SetStartDragDistance(l int) {
+	C.QApplication_setStartDragDistance((C.int)(l))
+}
+
+func QApplication_StartDragDistance() int {
+	return (int)(C.QApplication_startDragDistance())
+}
+
+func QApplication_IsEffectEnabled(param1 UIEffect) bool {
+	return (bool)(C.QApplication_isEffectEnabled((C.int)(param1)))
+}
+
+func QApplication_SetEffectEnabled(param1 UIEffect) {
+	C.QApplication_setEffectEnabled((C.int)(param1))
+}
+
+func QApplication_Exec() int {
+	return (int)(C.QApplication_exec())
+}
+
+func (this *QApplication) Notify(param1 *QObject, param2 *QEvent) bool {
+	return (bool)(C.QApplication_notify(this.h, param1.cPointer(), param2.cPointer()))
+}
+
+func (this *QApplication) FocusChanged(old *QWidget, now *QWidget) {
+	C.QApplication_focusChanged(this.h, old.cPointer(), now.cPointer())
+}
+func (this *QApplication) OnFocusChanged(slot func(old *QWidget, now *QWidget)) {
+	C.QApplication_connect_focusChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
+}
+
+//export miqt_exec_callback_QApplication_focusChanged
+func miqt_exec_callback_QApplication_focusChanged(cb C.intptr_t, old *C.QWidget, now *C.QWidget) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(old *QWidget, now *QWidget))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQWidget(old)
+
+	slotval2 := newQWidget(now)
+
+	gofunc(slotval1, slotval2)
+}
+
+func (this *QApplication) StyleSheet() string {
+	var _ms C.struct_miqt_string = C.QApplication_styleSheet(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QApplication) SetStyleSheet(sheet string) {
+	sheet_ms := C.struct_miqt_string{}
+	sheet_ms.data = C.CString(sheet)
+	sheet_ms.len = C.size_t(len(sheet))
+	defer C.free(unsafe.Pointer(sheet_ms.data))
+	C.QApplication_setStyleSheet(this.h, sheet_ms)
+}
+
+func (this *QApplication) SetAutoSipEnabled(enabled bool) {
+	C.QApplication_setAutoSipEnabled(this.h, (C.bool)(enabled))
+}
+
+func (this *QApplication) AutoSipEnabled() bool {
+	return (bool)(C.QApplication_autoSipEnabled(this.h))
+}
+
+func QApplication_CloseAllWindows() {
+	C.QApplication_closeAllWindows()
+}
+
+func QApplication_AboutQt() {
+	C.QApplication_aboutQt()
+}
+
+func QApplication_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QApplication_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QApplication_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QApplication_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QApplication_SetPalette2(param1 *QPalette, className string) {
+	className_Cstring := C.CString(className)
+	defer C.free(unsafe.Pointer(className_Cstring))
+	C.QApplication_setPalette2(param1.cPointer(), className_Cstring)
+}
+
+func QApplication_SetFont2(param1 *QFont, className string) {
+	className_Cstring := C.CString(className)
+	defer C.free(unsafe.Pointer(className_Cstring))
+	C.QApplication_setFont2(param1.cPointer(), className_Cstring)
+}
+
+func QApplication_Alert2(widget *QWidget, duration int) {
+	C.QApplication_alert2(widget.cPointer(), (C.int)(duration))
+}
+
+func QApplication_SetEffectEnabled2(param1 UIEffect, enable bool) {
+	C.QApplication_setEffectEnabled2((C.int)(param1), (C.bool)(enable))
+}
+
+// ResolveInterface can only be called from a QApplication that was directly constructed.
+func (this *QApplication) ResolveInterface(name string, revision int) unsafe.Pointer {
+	name_Cstring := C.CString(name)
+	defer C.free(unsafe.Pointer(name_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (unsafe.Pointer)(C.QApplication_protectedbase_resolveInterface(&_dynamic_cast_ok, unsafe.Pointer(this.h), name_Cstring, (C.int)(revision)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Sender can only be called from a QApplication that was directly constructed.
+func (this *QApplication) Sender() *QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := newQObject(C.QApplication_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QApplication that was directly constructed.
+func (this *QApplication) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QApplication_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QApplication that was directly constructed.
+func (this *QApplication) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QApplication_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QApplication that was directly constructed.
+func (this *QApplication) IsSignalConnected(signal *QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QApplication_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal.cPointer()))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+func (this *QApplication) callVirtualBase_Notify(param1 *QObject, param2 *QEvent) bool {
+
+	return (bool)(C.QApplication_virtualbase_notify(unsafe.Pointer(this.h), param1.cPointer(), param2.cPointer()))
+
+}
+func (this *QApplication) OnNotify(slot func(super func(param1 *QObject, param2 *QEvent) bool, param1 *QObject, param2 *QEvent) bool) {
+	ok := C.QApplication_override_virtual_notify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_notify
+func miqt_exec_callback_QApplication_notify(self *C.QApplication, cb C.intptr_t, param1 *C.QObject, param2 *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *QObject, param2 *QEvent) bool, param1 *QObject, param2 *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQObject(param1)
+
+	slotval2 := newQEvent(param2)
+
+	virtualReturn := gofunc((&QApplication{h: self}).callVirtualBase_Notify, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QApplication) callVirtualBase_Event(param1 *QEvent) bool {
+
+	return (bool)(C.QApplication_virtualbase_event(unsafe.Pointer(this.h), param1.cPointer()))
+
+}
+func (this *QApplication) OnEvent(slot func(super func(param1 *QEvent) bool, param1 *QEvent) bool) {
+	ok := C.QApplication_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_event
+func miqt_exec_callback_QApplication_event(self *C.QApplication, cb C.intptr_t, param1 *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *QEvent) bool, param1 *QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := newQEvent(param1)
+
+	virtualReturn := gofunc((&QApplication{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QApplication) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool {
+
+	return (bool)(C.QApplication_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer()))
+
+}
+func (this *QApplication) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) {
+	ok := C.QApplication_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_eventFilter
+func miqt_exec_callback_QApplication_eventFilter(self *C.QApplication, 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 := newQObject(watched)
+
+	slotval2 := newQEvent(event)
+
+	virtualReturn := gofunc((&QApplication{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QApplication) callVirtualBase_TimerEvent(event *QTimerEvent) {
+
+	C.QApplication_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QApplication) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) {
+	ok := C.QApplication_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_timerEvent
+func miqt_exec_callback_QApplication_timerEvent(self *C.QApplication, 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 := newQTimerEvent(event)
+
+	gofunc((&QApplication{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QApplication) callVirtualBase_ChildEvent(event *QChildEvent) {
+
+	C.QApplication_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QApplication) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) {
+	ok := C.QApplication_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_childEvent
+func miqt_exec_callback_QApplication_childEvent(self *C.QApplication, 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 := newQChildEvent(event)
+
+	gofunc((&QApplication{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QApplication) callVirtualBase_CustomEvent(event *QEvent) {
+
+	C.QApplication_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer())
+
+}
+func (this *QApplication) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) {
+	ok := C.QApplication_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_customEvent
+func miqt_exec_callback_QApplication_customEvent(self *C.QApplication, 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 := newQEvent(event)
+
+	gofunc((&QApplication{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QApplication) callVirtualBase_ConnectNotify(signal *QMetaMethod) {
+
+	C.QApplication_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QApplication) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QApplication_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_connectNotify
+func miqt_exec_callback_QApplication_connectNotify(self *C.QApplication, 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 := newQMetaMethod(signal)
+
+	gofunc((&QApplication{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QApplication) callVirtualBase_DisconnectNotify(signal *QMetaMethod) {
+
+	C.QApplication_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer())
+
+}
+func (this *QApplication) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) {
+	ok := C.QApplication_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QApplication_disconnectNotify
+func miqt_exec_callback_QApplication_disconnectNotify(self *C.QApplication, 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 := newQMetaMethod(signal)
+
+	gofunc((&QApplication{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QApplication) Delete() {
+	C.QApplication_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QApplication) GoGC() {
+	runtime.SetFinalizer(this, func(this *QApplication) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qapplication.h

@@ -0,0 +1,142 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QAPPLICATION_H
+#define MIQT_QT6_GEN_QAPPLICATION_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QApplication;
+class QChildEvent;
+class QCoreApplication;
+class QEvent;
+class QFont;
+class QFontMetrics;
+class QGuiApplication;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QPalette;
+class QPoint;
+class QStyle;
+class QTimerEvent;
+class QWidget;
+#else
+typedef struct QApplication QApplication;
+typedef struct QChildEvent QChildEvent;
+typedef struct QCoreApplication QCoreApplication;
+typedef struct QEvent QEvent;
+typedef struct QFont QFont;
+typedef struct QFontMetrics QFontMetrics;
+typedef struct QGuiApplication QGuiApplication;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QPalette QPalette;
+typedef struct QPoint QPoint;
+typedef struct QStyle QStyle;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QWidget QWidget;
+#endif
+
+QApplication* QApplication_new(int* argc, char** argv);
+QApplication* QApplication_new2(int* argc, char** argv, int param3);
+void QApplication_virtbase(QApplication* src, QGuiApplication** outptr_QGuiApplication);
+QMetaObject* QApplication_metaObject(const QApplication* self);
+void* QApplication_metacast(QApplication* self, const char* param1);
+struct miqt_string QApplication_tr(const char* s);
+QStyle* QApplication_style();
+void QApplication_setStyle(QStyle* style);
+QStyle* QApplication_setStyleWithStyle(struct miqt_string style);
+QPalette* QApplication_palette(QWidget* param1);
+QPalette* QApplication_paletteWithClassName(const char* className);
+void QApplication_setPalette(QPalette* param1);
+QFont* QApplication_font();
+QFont* QApplication_fontWithQWidget(QWidget* param1);
+QFont* QApplication_fontWithClassName(const char* className);
+void QApplication_setFont(QFont* param1);
+QFontMetrics* QApplication_fontMetrics();
+struct miqt_array /* of QWidget* */  QApplication_allWidgets();
+struct miqt_array /* of QWidget* */  QApplication_topLevelWidgets();
+QWidget* QApplication_activePopupWidget();
+QWidget* QApplication_activeModalWidget();
+QWidget* QApplication_focusWidget();
+QWidget* QApplication_activeWindow();
+void QApplication_setActiveWindow(QWidget* act);
+QWidget* QApplication_widgetAt(QPoint* p);
+QWidget* QApplication_widgetAt2(int x, int y);
+QWidget* QApplication_topLevelAt(QPoint* p);
+QWidget* QApplication_topLevelAt2(int x, int y);
+void QApplication_beep();
+void QApplication_alert(QWidget* widget);
+void QApplication_setCursorFlashTime(int cursorFlashTime);
+int QApplication_cursorFlashTime();
+void QApplication_setDoubleClickInterval(int doubleClickInterval);
+int QApplication_doubleClickInterval();
+void QApplication_setKeyboardInputInterval(int keyboardInputInterval);
+int QApplication_keyboardInputInterval();
+void QApplication_setWheelScrollLines(int wheelScrollLines);
+int QApplication_wheelScrollLines();
+void QApplication_setStartDragTime(int ms);
+int QApplication_startDragTime();
+void QApplication_setStartDragDistance(int l);
+int QApplication_startDragDistance();
+bool QApplication_isEffectEnabled(int param1);
+void QApplication_setEffectEnabled(int param1);
+int QApplication_exec();
+bool QApplication_notify(QApplication* self, QObject* param1, QEvent* param2);
+void QApplication_focusChanged(QApplication* self, QWidget* old, QWidget* now);
+void QApplication_connect_focusChanged(QApplication* self, intptr_t slot);
+struct miqt_string QApplication_styleSheet(const QApplication* self);
+void QApplication_setStyleSheet(QApplication* self, struct miqt_string sheet);
+void QApplication_setAutoSipEnabled(QApplication* self, const bool enabled);
+bool QApplication_autoSipEnabled(const QApplication* self);
+void QApplication_closeAllWindows();
+void QApplication_aboutQt();
+bool QApplication_event(QApplication* self, QEvent* param1);
+struct miqt_string QApplication_tr2(const char* s, const char* c);
+struct miqt_string QApplication_tr3(const char* s, const char* c, int n);
+void QApplication_setPalette2(QPalette* param1, const char* className);
+void QApplication_setFont2(QFont* param1, const char* className);
+void QApplication_alert2(QWidget* widget, int duration);
+void QApplication_setEffectEnabled2(int param1, bool enable);
+
+bool QApplication_override_virtual_notify(void* self, intptr_t slot);
+bool QApplication_virtualbase_notify(void* self, QObject* param1, QEvent* param2);
+bool QApplication_override_virtual_event(void* self, intptr_t slot);
+bool QApplication_virtualbase_event(void* self, QEvent* param1);
+bool QApplication_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QApplication_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QApplication_override_virtual_timerEvent(void* self, intptr_t slot);
+void QApplication_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QApplication_override_virtual_childEvent(void* self, intptr_t slot);
+void QApplication_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QApplication_override_virtual_customEvent(void* self, intptr_t slot);
+void QApplication_virtualbase_customEvent(void* self, QEvent* event);
+bool QApplication_override_virtual_connectNotify(void* self, intptr_t slot);
+void QApplication_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QApplication_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QApplication_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void* QApplication_protectedbase_resolveInterface(bool* _dynamic_cast_ok, const void* self, const char* name, int revision);
+QObject* QApplication_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QApplication_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QApplication_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QApplication_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QApplication_delete(QApplication* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qarraydata.cpp

@@ -0,0 +1,11 @@
+#include <qarraydata.h>
+#include "gen_qarraydata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+

vendor/github.com/mappu/miqt/qt6/gen_qarraydata.go

@@ -0,0 +1,39 @@
+package qt6
+
+/*
+
+#include "gen_qarraydata.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+type QArrayData__AllocationOption int
+
+const (
+	QArrayData__Grow     QArrayData__AllocationOption = 0
+	QArrayData__KeepSize QArrayData__AllocationOption = 1
+)
+
+type QArrayData__GrowthPosition int
+
+const (
+	QArrayData__GrowsAtEnd       QArrayData__GrowthPosition = 0
+	QArrayData__GrowsAtBeginning QArrayData__GrowthPosition = 1
+)
+
+type QArrayData__ArrayOption int
+
+const (
+	QArrayData__ArrayOptionDefault QArrayData__ArrayOption = 0
+	QArrayData__CapacityReserved   QArrayData__ArrayOption = 1
+)
+
+type QtPrivate__QContainerImplHelper__CutResult int
+
+const (
+	QtPrivate__QContainerImplHelper__Null   QtPrivate__QContainerImplHelper__CutResult = 0
+	QtPrivate__QContainerImplHelper__Empty  QtPrivate__QContainerImplHelper__CutResult = 1
+	QtPrivate__QContainerImplHelper__Full   QtPrivate__QContainerImplHelper__CutResult = 2
+	QtPrivate__QContainerImplHelper__Subset QtPrivate__QContainerImplHelper__CutResult = 3
+)

vendor/github.com/mappu/miqt/qt6/gen_qarraydata.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QARRAYDATA_H
+#define MIQT_QT6_GEN_QARRAYDATA_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#else
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qbackingstore.cpp

@@ -0,0 +1,77 @@
+#include <QBackingStore>
+#include <QPaintDevice>
+#include <QPoint>
+#include <QRegion>
+#include <QSize>
+#include <QWindow>
+#include <qbackingstore.h>
+#include "gen_qbackingstore.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QBackingStore* QBackingStore_new(QWindow* window) {
+	return new (std::nothrow) QBackingStore(window);
+}
+
+QWindow* QBackingStore_window(const QBackingStore* self) {
+	return self->window();
+}
+
+QPaintDevice* QBackingStore_paintDevice(QBackingStore* self) {
+	return self->paintDevice();
+}
+
+void QBackingStore_flush(QBackingStore* self, QRegion* region) {
+	self->flush(*region);
+}
+
+void QBackingStore_resize(QBackingStore* self, QSize* size) {
+	self->resize(*size);
+}
+
+QSize* QBackingStore_size(const QBackingStore* self) {
+	return new QSize(self->size());
+}
+
+bool QBackingStore_scroll(QBackingStore* self, QRegion* area, int dx, int dy) {
+	return self->scroll(*area, static_cast<int>(dx), static_cast<int>(dy));
+}
+
+void QBackingStore_beginPaint(QBackingStore* self, QRegion* param1) {
+	self->beginPaint(*param1);
+}
+
+void QBackingStore_endPaint(QBackingStore* self) {
+	self->endPaint();
+}
+
+void QBackingStore_setStaticContents(QBackingStore* self, QRegion* region) {
+	self->setStaticContents(*region);
+}
+
+QRegion* QBackingStore_staticContents(const QBackingStore* self) {
+	return new QRegion(self->staticContents());
+}
+
+bool QBackingStore_hasStaticContents(const QBackingStore* self) {
+	return self->hasStaticContents();
+}
+
+void QBackingStore_flush2(QBackingStore* self, QRegion* region, QWindow* window) {
+	self->flush(*region, window);
+}
+
+void QBackingStore_flush3(QBackingStore* self, QRegion* region, QWindow* window, QPoint* offset) {
+	self->flush(*region, window, *offset);
+}
+
+void QBackingStore_delete(QBackingStore* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qbackingstore.go

@@ -0,0 +1,122 @@
+package qt6
+
+/*
+
+#include "gen_qbackingstore.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QBackingStore struct {
+	h *C.QBackingStore
+}
+
+func (this *QBackingStore) cPointer() *C.QBackingStore {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBackingStore) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBackingStore constructs the type using only CGO pointers.
+func newQBackingStore(h *C.QBackingStore) *QBackingStore {
+	if h == nil {
+		return nil
+	}
+
+	return &QBackingStore{h: h}
+}
+
+// UnsafeNewQBackingStore constructs the type using only unsafe pointers.
+func UnsafeNewQBackingStore(h unsafe.Pointer) *QBackingStore {
+	return newQBackingStore((*C.QBackingStore)(h))
+}
+
+// NewQBackingStore constructs a new QBackingStore object.
+func NewQBackingStore(window *QWindow) *QBackingStore {
+
+	return newQBackingStore(C.QBackingStore_new(window.cPointer()))
+}
+
+func (this *QBackingStore) Window() *QWindow {
+	return newQWindow(C.QBackingStore_window(this.h))
+}
+
+func (this *QBackingStore) PaintDevice() *QPaintDevice {
+	return newQPaintDevice(C.QBackingStore_paintDevice(this.h))
+}
+
+func (this *QBackingStore) Flush(region *QRegion) {
+	C.QBackingStore_flush(this.h, region.cPointer())
+}
+
+func (this *QBackingStore) Resize(size *QSize) {
+	C.QBackingStore_resize(this.h, size.cPointer())
+}
+
+func (this *QBackingStore) Size() *QSize {
+	_goptr := newQSize(C.QBackingStore_size(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QBackingStore) Scroll(area *QRegion, dx int, dy int) bool {
+	return (bool)(C.QBackingStore_scroll(this.h, area.cPointer(), (C.int)(dx), (C.int)(dy)))
+}
+
+func (this *QBackingStore) BeginPaint(param1 *QRegion) {
+	C.QBackingStore_beginPaint(this.h, param1.cPointer())
+}
+
+func (this *QBackingStore) EndPaint() {
+	C.QBackingStore_endPaint(this.h)
+}
+
+func (this *QBackingStore) SetStaticContents(region *QRegion) {
+	C.QBackingStore_setStaticContents(this.h, region.cPointer())
+}
+
+func (this *QBackingStore) StaticContents() *QRegion {
+	_goptr := newQRegion(C.QBackingStore_staticContents(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QBackingStore) HasStaticContents() bool {
+	return (bool)(C.QBackingStore_hasStaticContents(this.h))
+}
+
+func (this *QBackingStore) Flush2(region *QRegion, window *QWindow) {
+	C.QBackingStore_flush2(this.h, region.cPointer(), window.cPointer())
+}
+
+func (this *QBackingStore) Flush3(region *QRegion, window *QWindow, offset *QPoint) {
+	C.QBackingStore_flush3(this.h, region.cPointer(), window.cPointer(), offset.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QBackingStore) Delete() {
+	C.QBackingStore_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBackingStore) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBackingStore) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qbackingstore.h

@@ -0,0 +1,54 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QBACKINGSTORE_H
+#define MIQT_QT6_GEN_QBACKINGSTORE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QBackingStore;
+class QPaintDevice;
+class QPoint;
+class QRegion;
+class QSize;
+class QWindow;
+#else
+typedef struct QBackingStore QBackingStore;
+typedef struct QPaintDevice QPaintDevice;
+typedef struct QPoint QPoint;
+typedef struct QRegion QRegion;
+typedef struct QSize QSize;
+typedef struct QWindow QWindow;
+#endif
+
+QBackingStore* QBackingStore_new(QWindow* window);
+QWindow* QBackingStore_window(const QBackingStore* self);
+QPaintDevice* QBackingStore_paintDevice(QBackingStore* self);
+void QBackingStore_flush(QBackingStore* self, QRegion* region);
+void QBackingStore_resize(QBackingStore* self, QSize* size);
+QSize* QBackingStore_size(const QBackingStore* self);
+bool QBackingStore_scroll(QBackingStore* self, QRegion* area, int dx, int dy);
+void QBackingStore_beginPaint(QBackingStore* self, QRegion* param1);
+void QBackingStore_endPaint(QBackingStore* self);
+void QBackingStore_setStaticContents(QBackingStore* self, QRegion* region);
+QRegion* QBackingStore_staticContents(const QBackingStore* self);
+bool QBackingStore_hasStaticContents(const QBackingStore* self);
+void QBackingStore_flush2(QBackingStore* self, QRegion* region, QWindow* window);
+void QBackingStore_flush3(QBackingStore* self, QRegion* region, QWindow* window, QPoint* offset);
+
+void QBackingStore_delete(QBackingStore* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qbasictimer.cpp

@@ -0,0 +1,45 @@
+#include <QBasicTimer>
+#include <QObject>
+#include <qbasictimer.h>
+#include "gen_qbasictimer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QBasicTimer* QBasicTimer_new() {
+	return new (std::nothrow) QBasicTimer();
+}
+
+void QBasicTimer_swap(QBasicTimer* self, QBasicTimer* other) {
+	self->swap(*other);
+}
+
+bool QBasicTimer_isActive(const QBasicTimer* self) {
+	return self->isActive();
+}
+
+int QBasicTimer_timerId(const QBasicTimer* self) {
+	return self->timerId();
+}
+
+void QBasicTimer_start(QBasicTimer* self, int msec, QObject* obj) {
+	self->start(static_cast<int>(msec), obj);
+}
+
+void QBasicTimer_start2(QBasicTimer* self, int msec, int timerType, QObject* obj) {
+	self->start(static_cast<int>(msec), static_cast<Qt::TimerType>(timerType), obj);
+}
+
+void QBasicTimer_stop(QBasicTimer* self) {
+	self->stop();
+}
+
+void QBasicTimer_delete(QBasicTimer* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qbasictimer.go

@@ -0,0 +1,90 @@
+package qt6
+
+/*
+
+#include "gen_qbasictimer.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QBasicTimer struct {
+	h *C.QBasicTimer
+}
+
+func (this *QBasicTimer) cPointer() *C.QBasicTimer {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBasicTimer) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBasicTimer constructs the type using only CGO pointers.
+func newQBasicTimer(h *C.QBasicTimer) *QBasicTimer {
+	if h == nil {
+		return nil
+	}
+
+	return &QBasicTimer{h: h}
+}
+
+// UnsafeNewQBasicTimer constructs the type using only unsafe pointers.
+func UnsafeNewQBasicTimer(h unsafe.Pointer) *QBasicTimer {
+	return newQBasicTimer((*C.QBasicTimer)(h))
+}
+
+// NewQBasicTimer constructs a new QBasicTimer object.
+func NewQBasicTimer() *QBasicTimer {
+
+	return newQBasicTimer(C.QBasicTimer_new())
+}
+
+func (this *QBasicTimer) Swap(other *QBasicTimer) {
+	C.QBasicTimer_swap(this.h, other.cPointer())
+}
+
+func (this *QBasicTimer) IsActive() bool {
+	return (bool)(C.QBasicTimer_isActive(this.h))
+}
+
+func (this *QBasicTimer) TimerId() int {
+	return (int)(C.QBasicTimer_timerId(this.h))
+}
+
+func (this *QBasicTimer) Start(msec int, obj *QObject) {
+	C.QBasicTimer_start(this.h, (C.int)(msec), obj.cPointer())
+}
+
+func (this *QBasicTimer) Start2(msec int, timerType TimerType, obj *QObject) {
+	C.QBasicTimer_start2(this.h, (C.int)(msec), (C.int)(timerType), obj.cPointer())
+}
+
+func (this *QBasicTimer) Stop() {
+	C.QBasicTimer_stop(this.h)
+}
+
+// Delete this object from C++ memory.
+func (this *QBasicTimer) Delete() {
+	C.QBasicTimer_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBasicTimer) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBasicTimer) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qbasictimer.h

@@ -0,0 +1,39 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QBASICTIMER_H
+#define MIQT_QT6_GEN_QBASICTIMER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QBasicTimer;
+class QObject;
+#else
+typedef struct QBasicTimer QBasicTimer;
+typedef struct QObject QObject;
+#endif
+
+QBasicTimer* QBasicTimer_new();
+void QBasicTimer_swap(QBasicTimer* self, QBasicTimer* other);
+bool QBasicTimer_isActive(const QBasicTimer* self);
+int QBasicTimer_timerId(const QBasicTimer* self);
+void QBasicTimer_start(QBasicTimer* self, int msec, QObject* obj);
+void QBasicTimer_start2(QBasicTimer* self, int msec, int timerType, QObject* obj);
+void QBasicTimer_stop(QBasicTimer* self);
+
+void QBasicTimer_delete(QBasicTimer* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qbindingstorage.cpp

@@ -0,0 +1,47 @@
+#include <QBindingStatus>
+#include <QBindingStorage>
+#include <QUntypedPropertyData>
+#include <qbindingstorage.h>
+#include "gen_qbindingstorage.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+void* QBindingStatus_threadId(const QBindingStatus* self) {
+	Qt::HANDLE threadId_ret = self->threadId;
+	return static_cast<void*>(threadId_ret);
+}
+
+void QBindingStatus_setThreadId(QBindingStatus* self, void* threadId) {
+	self->threadId = threadId;
+}
+
+void QBindingStatus_delete(QBindingStatus* self) {
+	delete self;
+}
+
+QBindingStorage* QBindingStorage_new() {
+	return new (std::nothrow) QBindingStorage();
+}
+
+bool QBindingStorage_isEmpty(QBindingStorage* self) {
+	return self->isEmpty();
+}
+
+bool QBindingStorage_isValid(const QBindingStorage* self) {
+	return self->isValid();
+}
+
+void QBindingStorage_registerDependency(const QBindingStorage* self, QUntypedPropertyData* data) {
+	self->registerDependency(data);
+}
+
+void QBindingStorage_delete(QBindingStorage* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qbindingstorage.go

@@ -0,0 +1,132 @@
+package qt6
+
+/*
+
+#include "gen_qbindingstorage.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QBindingStatus struct {
+	h *C.QBindingStatus
+}
+
+func (this *QBindingStatus) cPointer() *C.QBindingStatus {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBindingStatus) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBindingStatus constructs the type using only CGO pointers.
+func newQBindingStatus(h *C.QBindingStatus) *QBindingStatus {
+	if h == nil {
+		return nil
+	}
+
+	return &QBindingStatus{h: h}
+}
+
+// UnsafeNewQBindingStatus constructs the type using only unsafe pointers.
+func UnsafeNewQBindingStatus(h unsafe.Pointer) *QBindingStatus {
+	return newQBindingStatus((*C.QBindingStatus)(h))
+}
+
+func (this *QBindingStatus) ThreadId() unsafe.Pointer {
+	return (unsafe.Pointer)(C.QBindingStatus_threadId(this.h))
+}
+
+func (this *QBindingStatus) SetThreadId(threadId unsafe.Pointer) {
+	C.QBindingStatus_setThreadId(this.h, threadId)
+}
+
+// Delete this object from C++ memory.
+func (this *QBindingStatus) Delete() {
+	C.QBindingStatus_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBindingStatus) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBindingStatus) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QBindingStorage struct {
+	h *C.QBindingStorage
+}
+
+func (this *QBindingStorage) cPointer() *C.QBindingStorage {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBindingStorage) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBindingStorage constructs the type using only CGO pointers.
+func newQBindingStorage(h *C.QBindingStorage) *QBindingStorage {
+	if h == nil {
+		return nil
+	}
+
+	return &QBindingStorage{h: h}
+}
+
+// UnsafeNewQBindingStorage constructs the type using only unsafe pointers.
+func UnsafeNewQBindingStorage(h unsafe.Pointer) *QBindingStorage {
+	return newQBindingStorage((*C.QBindingStorage)(h))
+}
+
+// NewQBindingStorage constructs a new QBindingStorage object.
+func NewQBindingStorage() *QBindingStorage {
+
+	return newQBindingStorage(C.QBindingStorage_new())
+}
+
+func (this *QBindingStorage) IsEmpty() bool {
+	return (bool)(C.QBindingStorage_isEmpty(this.h))
+}
+
+func (this *QBindingStorage) IsValid() bool {
+	return (bool)(C.QBindingStorage_isValid(this.h))
+}
+
+func (this *QBindingStorage) RegisterDependency(data *QUntypedPropertyData) {
+	C.QBindingStorage_registerDependency(this.h, data.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QBindingStorage) Delete() {
+	C.QBindingStorage_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBindingStorage) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBindingStorage) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qbindingstorage.h

@@ -0,0 +1,43 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QBINDINGSTORAGE_H
+#define MIQT_QT6_GEN_QBINDINGSTORAGE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QBindingStatus;
+class QBindingStorage;
+class QUntypedPropertyData;
+#else
+typedef struct QBindingStatus QBindingStatus;
+typedef struct QBindingStorage QBindingStorage;
+typedef struct QUntypedPropertyData QUntypedPropertyData;
+#endif
+
+void* QBindingStatus_threadId(const QBindingStatus* self);
+void QBindingStatus_setThreadId(QBindingStatus* self, void* threadId);
+
+void QBindingStatus_delete(QBindingStatus* self);
+
+QBindingStorage* QBindingStorage_new();
+bool QBindingStorage_isEmpty(QBindingStorage* self);
+bool QBindingStorage_isValid(const QBindingStorage* self);
+void QBindingStorage_registerDependency(const QBindingStorage* self, QUntypedPropertyData* data);
+
+void QBindingStorage_delete(QBindingStorage* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

vendor/github.com/mappu/miqt/qt6/gen_qbitarray.cpp

@@ -0,0 +1,190 @@
+#include <QBitArray>
+#include <QBitRef>
+#include <qbitarray.h>
+#include "gen_qbitarray.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QBitArray* QBitArray_new() {
+	return new (std::nothrow) QBitArray();
+}
+
+QBitArray* QBitArray_new2(ptrdiff_t size) {
+	return new (std::nothrow) QBitArray((qsizetype)(size));
+}
+
+QBitArray* QBitArray_new3(QBitArray* other) {
+	return new (std::nothrow) QBitArray(*other);
+}
+
+QBitArray* QBitArray_new4(ptrdiff_t size, bool val) {
+	return new (std::nothrow) QBitArray((qsizetype)(size), val);
+}
+
+void QBitArray_operatorAssign(QBitArray* self, QBitArray* other) {
+	self->operator=(*other);
+}
+
+void QBitArray_swap(QBitArray* self, QBitArray* other) {
+	self->swap(*other);
+}
+
+ptrdiff_t QBitArray_size(const QBitArray* self) {
+	qsizetype _ret = self->size();
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+ptrdiff_t QBitArray_count(const QBitArray* self) {
+	qsizetype _ret = self->count();
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+ptrdiff_t QBitArray_countWithOn(const QBitArray* self, bool on) {
+	qsizetype _ret = self->count(on);
+	return static_cast<ptrdiff_t>(_ret);
+}
+
+bool QBitArray_isEmpty(const QBitArray* self) {
+	return self->isEmpty();
+}
+
+bool QBitArray_isNull(const QBitArray* self) {
+	return self->isNull();
+}
+
+void QBitArray_resize(QBitArray* self, ptrdiff_t size) {
+	self->resize((qsizetype)(size));
+}
+
+void QBitArray_detach(QBitArray* self) {
+	self->detach();
+}
+
+bool QBitArray_isDetached(const QBitArray* self) {
+	return self->isDetached();
+}
+
+void QBitArray_clear(QBitArray* self) {
+	self->clear();
+}
+
+bool QBitArray_testBit(const QBitArray* self, ptrdiff_t i) {
+	return self->testBit((qsizetype)(i));
+}
+
+void QBitArray_setBit(QBitArray* self, ptrdiff_t i) {
+	self->setBit((qsizetype)(i));
+}
+
+void QBitArray_setBit2(QBitArray* self, ptrdiff_t i, bool val) {
+	self->setBit((qsizetype)(i), val);
+}
+
+void QBitArray_clearBit(QBitArray* self, ptrdiff_t i) {
+	self->clearBit((qsizetype)(i));
+}
+
+bool QBitArray_toggleBit(QBitArray* self, ptrdiff_t i) {
+	return self->toggleBit((qsizetype)(i));
+}
+
+bool QBitArray_at(const QBitArray* self, ptrdiff_t i) {
+	return self->at((qsizetype)(i));
+}
+
+QBitRef* QBitArray_operatorSubscript(QBitArray* self, ptrdiff_t i) {
+	return new QBitRef(self->operator[]((qsizetype)(i)));
+}
+
+bool QBitArray_operatorSubscriptWithQsizetype(const QBitArray* self, ptrdiff_t i) {
+	return self->operator[]((qsizetype)(i));
+}
+
+void QBitArray_operatorBitwiseAndAssign(QBitArray* self, QBitArray* param1) {
+	self->operator&=(*param1);
+}
+
+void QBitArray_operatorBitwiseOrAssign(QBitArray* self, QBitArray* param1) {
+	self->operator|=(*param1);
+}
+
+void QBitArray_operatorBitwiseNotAssign(QBitArray* self, QBitArray* param1) {
+	self->operator^=(*param1);
+}
+
+bool QBitArray_operatorEqual(const QBitArray* self, QBitArray* other) {
+	return (*self == *other);
+}
+
+bool QBitArray_operatorNotEqual(const QBitArray* self, QBitArray* other) {
+	return (*self != *other);
+}
+
+bool QBitArray_fill(QBitArray* self, bool val) {
+	return self->fill(val);
+}
+
+void QBitArray_fill2(QBitArray* self, bool val, ptrdiff_t first, ptrdiff_t last) {
+	self->fill(val, (qsizetype)(first), (qsizetype)(last));
+}
+
+void QBitArray_truncate(QBitArray* self, ptrdiff_t pos) {
+	self->truncate((qsizetype)(pos));
+}
+
+const char* QBitArray_bits(const QBitArray* self) {
+	return (const char*) self->bits();
+}
+
+QBitArray* QBitArray_fromBits(const char* data, ptrdiff_t len) {
+	return new QBitArray(QBitArray::fromBits(data, (qsizetype)(len)));
+}
+
+unsigned int QBitArray_toUInt32(const QBitArray* self, int endianness) {
+	quint32 _ret = self->toUInt32(static_cast<QSysInfo::Endian>(endianness));
+	return static_cast<unsigned int>(_ret);
+}
+
+bool QBitArray_fill3(QBitArray* self, bool val, ptrdiff_t size) {
+	return self->fill(val, (qsizetype)(size));
+}
+
+unsigned int QBitArray_toUInt322(const QBitArray* self, int endianness, bool* ok) {
+	quint32 _ret = self->toUInt32(static_cast<QSysInfo::Endian>(endianness), ok);
+	return static_cast<unsigned int>(_ret);
+}
+
+void QBitArray_delete(QBitArray* self) {
+	delete self;
+}
+
+QBitRef* QBitRef_new(QBitRef* param1) {
+	return new (std::nothrow) QBitRef(*param1);
+}
+
+bool QBitRef_ToBool(const QBitRef* self) {
+	return self->operator bool();
+}
+
+bool QBitRef_operatorNot(const QBitRef* self) {
+	return self->operator!();
+}
+
+void QBitRef_operatorAssign(QBitRef* self, QBitRef* val) {
+	self->operator=(*val);
+}
+
+void QBitRef_operatorAssignWithVal(QBitRef* self, bool val) {
+	self->operator=(val);
+}
+
+void QBitRef_delete(QBitRef* self) {
+	delete self;
+}
+

vendor/github.com/mappu/miqt/qt6/gen_qbitarray.go

@@ -0,0 +1,287 @@
+package qt6
+
+/*
+
+#include "gen_qbitarray.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QBitArray struct {
+	h *C.QBitArray
+}
+
+func (this *QBitArray) cPointer() *C.QBitArray {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBitArray) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBitArray constructs the type using only CGO pointers.
+func newQBitArray(h *C.QBitArray) *QBitArray {
+	if h == nil {
+		return nil
+	}
+
+	return &QBitArray{h: h}
+}
+
+// UnsafeNewQBitArray constructs the type using only unsafe pointers.
+func UnsafeNewQBitArray(h unsafe.Pointer) *QBitArray {
+	return newQBitArray((*C.QBitArray)(h))
+}
+
+// NewQBitArray constructs a new QBitArray object.
+func NewQBitArray() *QBitArray {
+
+	return newQBitArray(C.QBitArray_new())
+}
+
+// NewQBitArray2 constructs a new QBitArray object.
+func NewQBitArray2(size int64) *QBitArray {
+
+	return newQBitArray(C.QBitArray_new2((C.ptrdiff_t)(size)))
+}
+
+// NewQBitArray3 constructs a new QBitArray object.
+func NewQBitArray3(other *QBitArray) *QBitArray {
+
+	return newQBitArray(C.QBitArray_new3(other.cPointer()))
+}
+
+// NewQBitArray4 constructs a new QBitArray object.
+func NewQBitArray4(size int64, val bool) *QBitArray {
+
+	return newQBitArray(C.QBitArray_new4((C.ptrdiff_t)(size), (C.bool)(val)))
+}
+
+func (this *QBitArray) OperatorAssign(other *QBitArray) {
+	C.QBitArray_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QBitArray) Swap(other *QBitArray) {
+	C.QBitArray_swap(this.h, other.cPointer())
+}
+
+func (this *QBitArray) Size() int64 {
+	return (int64)(C.QBitArray_size(this.h))
+}
+
+func (this *QBitArray) Count() int64 {
+	return (int64)(C.QBitArray_count(this.h))
+}
+
+func (this *QBitArray) CountWithOn(on bool) int64 {
+	return (int64)(C.QBitArray_countWithOn(this.h, (C.bool)(on)))
+}
+
+func (this *QBitArray) IsEmpty() bool {
+	return (bool)(C.QBitArray_isEmpty(this.h))
+}
+
+func (this *QBitArray) IsNull() bool {
+	return (bool)(C.QBitArray_isNull(this.h))
+}
+
+func (this *QBitArray) Resize(size int64) {
+	C.QBitArray_resize(this.h, (C.ptrdiff_t)(size))
+}
+
+func (this *QBitArray) Detach() {
+	C.QBitArray_detach(this.h)
+}
+
+func (this *QBitArray) IsDetached() bool {
+	return (bool)(C.QBitArray_isDetached(this.h))
+}
+
+func (this *QBitArray) Clear() {
+	C.QBitArray_clear(this.h)
+}
+
+func (this *QBitArray) TestBit(i int64) bool {
+	return (bool)(C.QBitArray_testBit(this.h, (C.ptrdiff_t)(i)))
+}
+
+func (this *QBitArray) SetBit(i int64) {
+	C.QBitArray_setBit(this.h, (C.ptrdiff_t)(i))
+}
+
+func (this *QBitArray) SetBit2(i int64, val bool) {
+	C.QBitArray_setBit2(this.h, (C.ptrdiff_t)(i), (C.bool)(val))
+}
+
+func (this *QBitArray) ClearBit(i int64) {
+	C.QBitArray_clearBit(this.h, (C.ptrdiff_t)(i))
+}
+
+func (this *QBitArray) ToggleBit(i int64) bool {
+	return (bool)(C.QBitArray_toggleBit(this.h, (C.ptrdiff_t)(i)))
+}
+
+func (this *QBitArray) At(i int64) bool {
+	return (bool)(C.QBitArray_at(this.h, (C.ptrdiff_t)(i)))
+}
+
+func (this *QBitArray) OperatorSubscript(i int64) *QBitRef {
+	_goptr := newQBitRef(C.QBitArray_operatorSubscript(this.h, (C.ptrdiff_t)(i)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QBitArray) OperatorSubscriptWithQsizetype(i int64) bool {
+	return (bool)(C.QBitArray_operatorSubscriptWithQsizetype(this.h, (C.ptrdiff_t)(i)))
+}
+
+func (this *QBitArray) OperatorBitwiseAndAssign(param1 *QBitArray) {
+	C.QBitArray_operatorBitwiseAndAssign(this.h, param1.cPointer())
+}
+
+func (this *QBitArray) OperatorBitwiseOrAssign(param1 *QBitArray) {
+	C.QBitArray_operatorBitwiseOrAssign(this.h, param1.cPointer())
+}
+
+func (this *QBitArray) OperatorBitwiseNotAssign(param1 *QBitArray) {
+	C.QBitArray_operatorBitwiseNotAssign(this.h, param1.cPointer())
+}
+
+func (this *QBitArray) OperatorEqual(other *QBitArray) bool {
+	return (bool)(C.QBitArray_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QBitArray) OperatorNotEqual(other *QBitArray) bool {
+	return (bool)(C.QBitArray_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QBitArray) Fill(val bool) bool {
+	return (bool)(C.QBitArray_fill(this.h, (C.bool)(val)))
+}
+
+func (this *QBitArray) Fill2(val bool, first int64, last int64) {
+	C.QBitArray_fill2(this.h, (C.bool)(val), (C.ptrdiff_t)(first), (C.ptrdiff_t)(last))
+}
+
+func (this *QBitArray) Truncate(pos int64) {
+	C.QBitArray_truncate(this.h, (C.ptrdiff_t)(pos))
+}
+
+func (this *QBitArray) Bits() string {
+	_ret := C.QBitArray_bits(this.h)
+	return C.GoString(_ret)
+}
+
+func QBitArray_FromBits(data string, lenVal int64) *QBitArray {
+	data_Cstring := C.CString(data)
+	defer C.free(unsafe.Pointer(data_Cstring))
+	_goptr := newQBitArray(C.QBitArray_fromBits(data_Cstring, (C.ptrdiff_t)(lenVal)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QBitArray) ToUInt32(endianness QSysInfo__Endian) uint {
+	return (uint)(C.QBitArray_toUInt32(this.h, (C.int)(endianness)))
+}
+
+func (this *QBitArray) Fill3(val bool, size int64) bool {
+	return (bool)(C.QBitArray_fill3(this.h, (C.bool)(val), (C.ptrdiff_t)(size)))
+}
+
+func (this *QBitArray) ToUInt322(endianness QSysInfo__Endian, ok *bool) uint {
+	return (uint)(C.QBitArray_toUInt322(this.h, (C.int)(endianness), (*C.bool)(unsafe.Pointer(ok))))
+}
+
+// Delete this object from C++ memory.
+func (this *QBitArray) Delete() {
+	C.QBitArray_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBitArray) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBitArray) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QBitRef struct {
+	h *C.QBitRef
+}
+
+func (this *QBitRef) cPointer() *C.QBitRef {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QBitRef) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQBitRef constructs the type using only CGO pointers.
+func newQBitRef(h *C.QBitRef) *QBitRef {
+	if h == nil {
+		return nil
+	}
+
+	return &QBitRef{h: h}
+}
+
+// UnsafeNewQBitRef constructs the type using only unsafe pointers.
+func UnsafeNewQBitRef(h unsafe.Pointer) *QBitRef {
+	return newQBitRef((*C.QBitRef)(h))
+}
+
+// NewQBitRef constructs a new QBitRef object.
+func NewQBitRef(param1 *QBitRef) *QBitRef {
+
+	return newQBitRef(C.QBitRef_new(param1.cPointer()))
+}
+
+func (this *QBitRef) ToBool() bool {
+	return (bool)(C.QBitRef_ToBool(this.h))
+}
+
+func (this *QBitRef) OperatorNot() bool {
+	return (bool)(C.QBitRef_operatorNot(this.h))
+}
+
+func (this *QBitRef) OperatorAssign(val *QBitRef) {
+	C.QBitRef_operatorAssign(this.h, val.cPointer())
+}
+
+func (this *QBitRef) OperatorAssignWithVal(val bool) {
+	C.QBitRef_operatorAssignWithVal(this.h, (C.bool)(val))
+}
+
+// Delete this object from C++ memory.
+func (this *QBitRef) Delete() {
+	C.QBitRef_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QBitRef) GoGC() {
+	runtime.SetFinalizer(this, func(this *QBitRef) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

vendor/github.com/mappu/miqt/qt6/gen_qbitarray.h

@@ -0,0 +1,76 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QBITARRAY_H
+#define MIQT_QT6_GEN_QBITARRAY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QBitArray;
+class QBitRef;
+#else
+typedef struct QBitArray QBitArray;
+typedef struct QBitRef QBitRef;
+#endif
+
+QBitArray* QBitArray_new();
+QBitArray* QBitArray_new2(ptrdiff_t size);
+QBitArray* QBitArray_new3(QBitArray* other);
+QBitArray* QBitArray_new4(ptrdiff_t size, bool val);
+void QBitArray_operatorAssign(QBitArray* self, QBitArray* other);
+void QBitArray_swap(QBitArray* self, QBitArray* other);
+ptrdiff_t QBitArray_size(const QBitArray* self);
+ptrdiff_t QBitArray_count(const QBitArray* self);
+ptrdiff_t QBitArray_countWithOn(const QBitArray* self, bool on);
+bool QBitArray_isEmpty(const QBitArray* self);
+bool QBitArray_isNull(const QBitArray* self);
+void QBitArray_resize(QBitArray* self, ptrdiff_t size);
+void QBitArray_detach(QBitArray* self);
+bool QBitArray_isDetached(const QBitArray* self);
+void QBitArray_clear(QBitArray* self);
+bool QBitArray_testBit(const QBitArray* self, ptrdiff_t i);
+void QBitArray_setBit(QBitArray* self, ptrdiff_t i);
+void QBitArray_setBit2(QBitArray* self, ptrdiff_t i, bool val);
+void QBitArray_clearBit(QBitArray* self, ptrdiff_t i);
+bool QBitArray_toggleBit(QBitArray* self, ptrdiff_t i);
+bool QBitArray_at(const QBitArray* self, ptrdiff_t i);
+QBitRef* QBitArray_operatorSubscript(QBitArray* self, ptrdiff_t i);
+bool QBitArray_operatorSubscriptWithQsizetype(const QBitArray* self, ptrdiff_t i);
+void QBitArray_operatorBitwiseAndAssign(QBitArray* self, QBitArray* param1);
+void QBitArray_operatorBitwiseOrAssign(QBitArray* self, QBitArray* param1);
+void QBitArray_operatorBitwiseNotAssign(QBitArray* self, QBitArray* param1);
+bool QBitArray_operatorEqual(const QBitArray* self, QBitArray* other);
+bool QBitArray_operatorNotEqual(const QBitArray* self, QBitArray* other);
+bool QBitArray_fill(QBitArray* self, bool val);
+void QBitArray_fill2(QBitArray* self, bool val, ptrdiff_t first, ptrdiff_t last);
+void QBitArray_truncate(QBitArray* self, ptrdiff_t pos);
+const char* QBitArray_bits(const QBitArray* self);
+QBitArray* QBitArray_fromBits(const char* data, ptrdiff_t len);
+unsigned int QBitArray_toUInt32(const QBitArray* self, int endianness);
+bool QBitArray_fill3(QBitArray* self, bool val, ptrdiff_t size);
+unsigned int QBitArray_toUInt322(const QBitArray* self, int endianness, bool* ok);
+
+void QBitArray_delete(QBitArray* self);
+
+QBitRef* QBitRef_new(QBitRef* param1);
+bool QBitRef_ToBool(const QBitRef* self);
+bool QBitRef_operatorNot(const QBitRef* self);
+void QBitRef_operatorAssign(QBitRef* self, QBitRef* val);
+void QBitRef_operatorAssignWithVal(QBitRef* self, bool val);
+
+void QBitRef_delete(QBitRef* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif